event_sourced_accounting 0.1.0

data/config/backtrace_silencers.rb

@@ -0,0 +1,7 @@
+# Be sure to restart your server when you modify this file.
+
+# You can add backtrace silencers for libraries that you're using but don't wish to see in your backtraces.
+# Rails.backtrace_cleaner.add_silencer { |line| line =~ /my_noisy_library/ }
+
+# You can also remove all the silencers if you're trying to debug a problem that might stem from framework code.
+# Rails.backtrace_cleaner.remove_silencers!

data/config/database.yml

@@ -0,0 +1,5 @@
+# config/database.yml in Rails
+test:
+  adapter: sqlite3
+  database: ":memory:"
+  timeout: 500

data/config/inflections.rb

@@ -0,0 +1,10 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new inflection rules using the following format
+# (all these examples are active by default):
+# ActiveSupport::Inflector.inflections do |inflect|
+#   inflect.plural /^(ox)$/i, '\1en'
+#   inflect.singular /^(ox)en/i, '\1'
+#   inflect.irregular 'person', 'people'
+#   inflect.uncountable %w( fish sheep )
+# end

data/config/mime_types.rb

@@ -0,0 +1,5 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new mime types for use in respond_to blocks:
+# Mime::Type.register "text/richtext", :rtf
+# Mime::Type.register_alias "text/html", :iphone

data/config/routes.rb

@@ -0,0 +1,6 @@
+ESA::Engine.routes.draw do
+  root :to => "accounts#index"
+
+  resources :accounts
+  resources :transactions
+end

data/config/secret_token.rb

@@ -0,0 +1,7 @@
+# Be sure to restart your server when you modify this file.
+
+# Your secret key for verifying the integrity of signed cookies.
+# If you change this key, all old signed cookies will become invalid!
+# Make sure the secret is at least 30 characters and all random,
+# no regular words or you'll be exposed to dictionary attacks.
+ESA::Application.config.secret_token = 'f6b9c48aaf200fda4bbcf1642319084d5e5cda2bd95ac0a43220aab19f4ee240f9cdab08b77c3284b3a6396b13b1fe8be12a227af04fc5f5a8b7a52b626c4fdd'

data/config/session_store.rb

@@ -0,0 +1,8 @@
+# Be sure to restart your server when you modify this file.
+
+ESA::Application.config.session_store :cookie_store, :key => '_esa_session'
+
+# Use the database for sessions instead of the cookie-based default,
+# which shouldn't be used to store highly confidential information
+# (create the session table with "rails generate session_migration")
+# Testtest::Application.config.session_store :active_record_store

data/lib/esa/balance_checker.rb

@@ -0,0 +1,17 @@
+module ESA
+  class BalanceChecker
+    def self.check(context)
+      if context.can_be_persisted? and not context.freshness.nil?
+        #context.event_count = context.events.created_before(context.freshness).count
+        #context.flag_count = context.flags.created_before(context.freshness).count
+        context.transaction_count = context.transactions.created_before(context.freshness).count
+        context.amount_count = context.amounts.created_before(context.freshness).count
+
+        context.debits_total = context.amounts.debits.created_before(context.freshness).total
+        context.credits_total = context.amounts.credits.created_before(context.freshness).total
+        context.opening_balance = context.opening_context.amounts.created_before(context.freshness).balance
+        context.closing_balance = context.closing_context.amounts.created_before(context.freshness).balance
+      end
+    end
+  end
+end

data/lib/esa/blocking_processor.rb

@@ -0,0 +1,158 @@
+module ESA
+  class BlockingProcessor
+    def self.enqueue(accountable)
+      if accountable.present? and accountable.class.ancestors.include? ESA::Traits::Accountable
+        process_accountable(accountable)
+      end
+    end
+
+    def self.process_accountable(accountable)
+      events_created = create_events(accountable)
+
+      if events_created
+        unprocessed_events = accountable.esa_events.
+            where(processed: false).
+            order('time ASC, created_at ASC')
+
+        unprocessed_events.each do |event|
+          event.processed = process_event(event)
+          event.save if event.changed?
+
+          # do not process later events if one fails
+          return false if not event.processed
+        end
+      else
+        false
+      end
+    end
+
+    def self.create_events(accountable)
+      produce_events(accountable).map(&:save).all?
+    end
+
+    def self.produce_events(accountable)
+      ruleset = Ruleset.extension_instance(accountable)
+      if ruleset.present?
+        last_event_time = accountable.esa_events.maximum(:time)
+        unrecorded_events = ruleset.unrecorded_events_as_attributes(accountable)
+        valid_events = unrecorded_events.select{|e| last_event_time.nil? or e[:time] >= last_event_time}
+        accountable.esa_events.new(valid_events)
+      else
+        []
+      end
+    end
+
+    def self.process_event(event)
+      flags_created = create_flags(event)
+
+      if flags_created
+        unprocessed_flags = []
+
+        if event.nature.adjustment?
+          unprocessed_flags += event.accountable.esa_flags.
+              where(adjusted: true, processed: false).
+              order('time ASC, created_at ASC')
+        end
+
+        unprocessed_flags += event.flags.
+            where(processed: false).
+            order('time ASC, created_at ASC')
+
+        unprocessed_flags.map do |flag|
+          flag.processed = process_flag(flag)
+          if flag.changed?
+            flag.save and flag.processed
+          else
+            flag.processed
+          end
+        end.all?
+      else
+        false
+      end
+    end
+
+    def self.create_flags(event)
+      if not event.processed and not event.processed_was
+        produce_flags(event).map(&:save).all?
+      else
+        true
+      end
+    end
+
+    def self.produce_flags(event)
+      flags = event.flags.all
+      if event.ruleset.present?
+        if event.nature.adjustment?
+          adjusted_flags = event.ruleset.flags_needing_adjustment(event.accountable)
+          adjusted_flags.map do |flag|
+            flag.processed = false
+            flag.adjusted = true
+            flag.adjustment_time = event.time
+
+            attrs = {
+              :accountable => event.accountable,
+              :nature => flag.nature,
+              :state => flag.state,
+              :event => event,
+            }
+
+            adjustment = event.accountable.esa_flags.new(attrs)
+            event.flags << adjustment
+
+            [flag, adjustment]
+          end.flatten
+        else
+          required_flags = event.ruleset.event_flags_as_attributes(event)
+          required_flags.map do |attrs|
+            existing = flags.find{|f| f.nature == attrs[:nature].to_s and f.state == attrs[:state]}
+            if existing.present?
+              existing
+            else
+              flag = event.accountable.esa_flags.new(attrs)
+              event.flags << flag
+              flag
+            end
+          end
+        end
+      else
+        flags
+      end
+    end
+
+    def self.process_flag(flag)
+      flag.transition ||= flag.accountable.esa_flags.transition_for(flag)
+      create_transactions(flag)
+    end
+
+    def self.create_transactions(flag)
+      if not flag.processed and not flag.processed_was
+        if flag.transition.present? and flag.transition.in? [-1, 0, 1]
+          produce_transactions(flag).map(&:save).all?
+        else
+          false
+        end
+      else
+        true
+      end
+    end
+
+    def self.produce_transactions(flag)
+      transactions = flag.transactions.all
+      if flag.ruleset.present? and flag.transition.present? and flag.transition.in? [-1, 0, 1]
+        required_transactions = flag.ruleset.flag_transactions_as_attributes(flag)
+        required_transactions.map do |attrs|
+          existing = transactions.find{|f| f.description == attrs[:description]}
+          if existing.present?
+            existing
+          else
+            transaction = flag.accountable.esa_transactions.new(attrs)
+            flag.transactions << transaction
+            transaction
+          end
+        end
+      else
+        transactions
+      end
+    end
+  end
+end

data/lib/esa/config.rb

@@ -0,0 +1,55 @@
+require 'esa/blocking_processor'
+require 'esa/balance_checker'
+require 'esa/subcontext_checker'
+
+module ESA
+  module Config
+    mattr_accessor :processor
+    self.processor = ESA::BlockingProcessor
+
+    mattr_accessor :context_checkers
+    self.context_checkers = Set.new
+    self.context_checkers << ESA::BalanceChecker
+    self.context_checkers << ESA::SubcontextChecker
+
+    mattr_accessor :context_providers
+    self.context_providers = {
+      'account'          => ESA::ContextProviders::AccountContextProvider,
+      'accountable'      => ESA::ContextProviders::AccountableContextProvider,
+      'accountable_type' => ESA::ContextProviders::AccountableTypeContextProvider,
+      'monthly'          => [ESA::ContextProviders::DateContextProvider, {period: :month}],
+      'daily'            => [ESA::ContextProviders::DateContextProvider, {period: :day}],
+    }
+
+    mattr_accessor :context_tree
+    self.context_tree = {
+      'account' => {
+        'monthly' => {
+          'daily' => {},
+        },
+      },
+      'monthly' => {
+        'account' => {
+          'daily' => {},
+        },
+      },
+      'daily' => {
+        'account' => {},
+      },
+    }
+
+    def self.walk_context_tree(path=[], tree=self.context_tree)
+      if path.respond_to? :count and path.count == 0
+        tree || {}
+      elsif path.respond_to? :first and tree.is_a? Hash and path.first.in? tree
+        walk_context_tree(path.drop(1), tree[path.first])
+      else
+        {}
+      end
+    end
+
+    def self.context_providers_for_path(path=[])
+      context_providers.slice(*walk_context_tree(path).keys)
+    end
+  end
+end

data/lib/esa/subcontext_checker.rb

@@ -0,0 +1,15 @@
+module ESA
+  class SubcontextChecker
+    def self.check(context)
+      ESA::Config.context_providers_for_path(context.effective_path).each do |namespace,provider|
+        if provider.is_a? Class and provider.respond_to? :check_subcontexts
+          provider.check_subcontexts(context, namespace)
+        elsif provider.respond_to? :count and provider.count == 2 and 
+              provider[0].is_a? Class and provider[0].respond_to? :check_subcontexts and provider[1].is_a? Hash
+          klass, options = provider
+          klass.check_subcontexts(context, namespace, options)
+        end
+      end
+    end
+  end
+end

data/lib/esa/version.rb

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

data/lib/esa.rb

@@ -0,0 +1,8 @@
+# ESA
+require "rails"
+require "enumerize"
+module ESA
+  class Engine < Rails::Engine
+    isolate_namespace ESA
+  end
+end

data/lib/generators/esa/USAGE

@@ -0,0 +1,11 @@
+Description:
+    Generator for ESA Plugin
+
+Example:
+    rails g esa
+
+    This will create:
+        Create a migration in the application for the "Account" and Transaction" tables.
+        
+    Once generated, simply run:
+        rake db:migrate

data/lib/generators/esa/esa_generator.rb

@@ -0,0 +1,26 @@
+# lib/generators/esa/esa_generator.rb
+require 'rails/generators'
+require 'rails/generators/migration'
+
+class ESAGenerator < Rails::Generators::Base
+ include Rails::Generators::Migration
+
+ def self.source_root
+		@source_root ||= File.join(File.dirname(__FILE__), 'templates')
+ end
+
+ # Implement the required interface for Rails::Generators::Migration.
+ # taken from http://github.com/rails/rails/blob/master/activerecord/lib/generators/active_record.rb
+ def self.next_migration_number(dirname)
+	 if ActiveRecord::Base.timestamped_migrations
+		 Time.now.utc.strftime("%Y%m%d%H%M%S")
+	 else
+		 "%.3d" % (current_migration_number(dirname) + 1)
+	 end
+ end
+
+ def create_migration_file
+	 migration_template 'migration.rb', 'db/migrate/create_esa_tables.rb'
+ end
+
+end

data/lib/generators/esa/templates/migration.rb

@@ -0,0 +1,142 @@
+class CreateEsaTables < ActiveRecord::Migration
+  def self.up
+    create_table :esa_charts do |t|
+      t.string :name
+
+      t.timestamps
+    end
+    add_index :esa_charts, [:name]
+
+    create_table :esa_accounts do |t|
+      t.string     :code
+      t.string     :name
+      t.string     :type
+      t.boolean    :contra
+      t.string     :normal_balance
+      t.references :chart
+
+      t.timestamps
+    end
+    add_index :esa_accounts, [:name, :type, :chart_id]
+    add_index :esa_accounts, :normal_balance
+
+    create_table :esa_events, :force => true do |t|
+      t.string     :type
+      t.datetime   :time
+      t.string     :nature
+      t.boolean    :processed
+      t.references :accountable, :polymorphic => true
+      t.references :ruleset
+
+      t.timestamps
+    end
+    add_index :esa_events, :type
+    add_index :esa_events, :time
+    add_index :esa_events, :nature
+    add_index :esa_events, [:accountable_id, :accountable_type], :name => "index_accountable_on_events"
+    add_index :esa_events, :ruleset_id
+    add_index :esa_events, [:time, :nature, :accountable_id, :accountable_type], :unique => true, :name => "unique_contents_on_events"
+
+    create_table :esa_flags, :force => true do |t|
+      t.string     :type
+      t.datetime   :time
+      t.string     :nature
+      t.boolean    :state
+      t.integer    :transition, :limit => 1
+      t.boolean    :processed
+      t.boolean    :adjusted
+      t.datetime   :adjustment_time
+      t.references :accountable, :polymorphic => true
+      t.references :event
+      t.references :ruleset
+
+      t.timestamps
+    end
+    add_index :esa_flags, :type
+    add_index :esa_flags, :time
+    add_index :esa_flags, :nature
+    add_index :esa_flags, [:accountable_id, :accountable_type], :name => "index_accountable_on_flags"
+    add_index :esa_flags, :event_id
+    add_index :esa_flags, :ruleset_id
+    add_index :esa_flags, [:time, :nature, :accountable_id, :accountable_type], :unique => true, :name => "unique_contents_on_flags"
+
+    create_table :esa_transactions do |t|
+      t.string     :type
+      t.datetime   :time
+      t.string     :description
+      t.references :accountable, :polymorphic => true
+      t.references :flag
+
+      t.timestamps
+    end
+    add_index :esa_transactions, [:accountable_id, :accountable_type], :name => "index_accountable_on_transactions"
+    add_index :esa_transactions, [:time, :description, :accountable_id, :accountable_type], :unique => true, :name => "unique_contents_on_transactions"
+
+    create_table :esa_rulesets, :force => true do |t|
+      t.string     :type
+      t.string     :name
+      t.references :chart
+
+      t.timestamps
+    end
+    add_index :esa_rulesets, :type
+    add_index :esa_rulesets, :chart_id
+
+    create_table :esa_amounts do |t|
+      t.string     :type
+      t.references :account
+      t.references :transaction
+      t.decimal    :amount, :precision => 20, :scale => 10
+
+      t.timestamps
+    end 
+    add_index :esa_amounts, :type
+    add_index :esa_amounts, [:account_id, :transaction_id]
+    add_index :esa_amounts, [:transaction_id, :account_id]
+    add_index :esa_amounts, [:type, :account_id, :transaction_id, :amount], :unique => true, :name => "unique_contents_on_amounts"
+
+    create_table :esa_contexts do |t|
+      t.string     :type
+      t.string     :name
+      t.references :chart
+      t.references :parent
+      t.references :account
+      t.references :accountable, :polymorphic => true
+      t.string     :namespace
+      t.integer    :position
+      t.date       :start_date
+      t.date       :end_date
+
+      t.datetime   :freshness
+      t.decimal    :event_count,       :precision => 16
+      t.decimal    :flag_count,        :precision => 16
+      t.decimal    :transaction_count, :precision => 16
+      t.decimal    :amount_count,      :precision => 16
+      t.decimal    :debits_total,    :precision => 20, :scale => 10
+      t.decimal    :credits_total,   :precision => 20, :scale => 10
+      t.decimal    :opening_balance, :precision => 20, :scale => 10
+      t.decimal    :closing_balance, :precision => 20, :scale => 10
+
+      t.timestamps
+    end
+    add_index :esa_contexts, [:type, :chart_id]
+    add_index :esa_contexts, :parent_id
+    add_index :esa_contexts, :account_id
+    add_index :esa_contexts, [:accountable_id, :accountable_type], :name => "index_accountable_on_contexts"
+    add_index :esa_contexts, :namespace
+    add_index :esa_contexts, :start_date
+    add_index :esa_contexts, :end_date
+    add_index :esa_contexts, :freshness
+  end
+
+  def self.down
+    drop_table :esa_charts
+    drop_table :esa_accounts
+    drop_table :esa_events
+    drop_table :esa_flags
+    drop_table :esa_transactions
+    drop_table :esa_rulesets
+    drop_table :esa_amounts
+    drop_table :esa_contexts
+  end
+end

data/spec/factories/account_factory.rb

@@ -0,0 +1,51 @@
+FactoryGirl.define do
+  factory :account, :class => ESA::Account do |account|
+    account.code
+    account.name
+    account.contra false
+    account.association :chart, :factory => :chart
+  end
+
+  factory :asset, :class => ESA::Accounts::Asset do |account|
+    account.code
+    account.name
+    account.contra false
+    account.association :chart, :factory => :chart
+  end
+
+  factory :equity, :class => ESA::Accounts::Equity do |account|
+    account.code
+    account.name
+    account.contra false
+    account.association :chart, :factory => :chart
+  end
+
+  factory :expense, :class => ESA::Accounts::Expense do |account|
+    account.code
+    account.name
+    account.contra false
+    account.association :chart, :factory => :chart
+  end
+
+  factory :liability, :class => ESA::Accounts::Liability do |account|
+    account.code
+    account.name
+    account.contra false
+    account.association :chart, :factory => :chart
+  end
+
+  factory :revenue, :class => ESA::Accounts::Revenue do |account|
+    account.code
+    account.name
+    account.contra false
+    account.association :chart, :factory => :chart
+  end
+
+  sequence :name do |n|
+    "Factory Name #{n}"
+  end
+
+  sequence :code do |n|
+    "#{n}"
+  end
+end

data/spec/factories/amount_factory.rb

@@ -0,0 +1,19 @@
+FactoryGirl.define do
+  factory :amount, :class => ESA::Amount do |amount|
+    amount.amount BigDecimal.new('473')
+    amount.association :transaction, :factory => :transaction_with_credit_and_debit
+    amount.association :account, :factory => :asset
+  end
+
+  factory :credit_amount, :class => ESA::Amounts::Credit do |credit_amount|
+    credit_amount.amount BigDecimal.new('473')
+    credit_amount.association :transaction, :factory => :transaction_with_credit_and_debit
+    credit_amount.association :account, :factory => :revenue
+  end
+
+  factory :debit_amount, :class => ESA::Amounts::Debit do |debit_amount|
+    debit_amount.amount BigDecimal.new('473')
+    debit_amount.association :transaction, :factory => :transaction_with_credit_and_debit
+    debit_amount.association :account, :factory => :asset
+  end
+end

data/spec/factories/chart_factory.rb

@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  factory :chart, :class => ESA::Chart do
+    id 1
+    name "Chart of Accounts"
+    initialize_with { ESA::Chart.find_or_create_by_id(id)}
+  end
+end

data/spec/factories/transaction_factory.rb

@@ -0,0 +1,11 @@
+FactoryGirl.define do
+  factory :transaction, :class => ESA::Transaction do |transaction|
+    transaction.description 'factory description'
+    factory :transaction_with_credit_and_debit, :class => ESA::Transaction do |transaction_cd|
+      transaction_cd.after_build do |t|
+        t.amounts << FactoryGirl.build(:credit_amount, :transaction => t)
+        t.amounts << FactoryGirl.build(:debit_amount, :transaction => t)
+      end
+    end
+  end
+end

data/spec/models/account_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+module ESA
+  describe Account do
+    let(:account) { FactoryGirl.build(:account) }
+    subject { account }
+    
+    # must construct a child type instead
+    it { should_not be_valid }
+
+    # must respond to normal_balance, but always answer "none"
+    it { should respond_to(:normal_balance) }
+    its(:normal_balance) { should be_kind_of(Enumerize::Value) }
+    its(:normal_balance) { should eq("none") }
+
+    # must respond to balance, but always answer nil
+    it { should respond_to(:balance) }
+    its(:balance) { should be_nil }
+
+    describe "when using a child type" do
+      let(:account) { FactoryGirl.create(:account, type: "Finance::Asset") }
+      it { should be_valid }
+      
+      it "should be unique per name" do
+        conflict = FactoryGirl.build(:account, name: account.name, type: account.type)
+        conflict.should_not be_valid
+        conflict.errors[:name].should == ["has already been taken"]
+      end
+    end
+  end
+end

data/spec/models/amount_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+module ESA
+  describe Amount do
+    subject { FactoryGirl.build(:amount) }
+    it { should_not be_valid }  # construct a child class instead
+  end
+end

data/spec/models/asset_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+module ESA
+  module Accounts
+    describe Asset do
+      it_behaves_like 'a ESA::Account subtype', kind: :asset, normal_balance: :debit
+    end
+  end
+end