aloe 0.1.0

data/lib/aloe/ledger_entry.rb

@@ -0,0 +1,83 @@
+require 'aloe/invalid_currency_error'
+require 'aloe/invalid_amount_error'
+require 'aloe/insufficient_balance_error'
+require 'aloe/inoperable_account_error'
+
+module Aloe
+  # LedgerEntry is use-case class that encompasses the process of moving funds
+  # between accounts.
+  class LedgerEntry < Struct.new(:amount, :options)
+
+    def initialize(*args)
+      super
+      raise Aloe::InvalidAmountError if amount.zero?
+      unless same_currencies?
+        raise Aloe::InvalidCurrencyError.new(debit_account, credit_account,
+          amount.currency)
+      end
+      unless debit_account.open?
+        raise Aloe::InoperableAccountError.new(debit_account)
+      end
+      unless credit_account.open?
+        raise Aloe::InoperableAccountError.new(credit_account)
+      end
+    end
+
+    def create!
+      ActiveRecord::Base.transaction do
+        debit_entry = debit_account.create_entry(-amount.cents)
+        credit_entry = credit_account.create_entry(amount.cents)
+        attributes = { credit_entry: credit_entry,
+                       debit_entry: debit_entry,
+                       category: category }.merge options
+        Aloe::Transaction::create! attributes
+      end
+    end
+
+    protected
+
+    def category
+      @category ||= options.delete(:type)
+    end
+
+    # @return [Aloe::Account]
+    def credit_account
+      @credit_account ||= may_find_account(options.delete(:to), currency)
+    end
+
+    # @return [String]
+    def currency
+      @currency ||= amount.currency
+    end
+
+    # @return [Aloe::Account]
+    def debit_account
+      @debit_account ||= may_find_account(options.delete(:from), currency)
+    end
+
+    # @return [Class]
+    def ledger
+      Aloe::Ledger
+    end
+
+    # @param [Object, Aloe::Aloe] account_or_owner
+    # @param [String, Symbol] currency
+    # @return [Aloe::Account]
+    def may_find_account(account_or_owner, currency)
+      if account_or_owner.respond_to?(:create_entry)
+        account_or_owner
+      elsif account_or_owner
+        ledger.find_account account_or_owner, currency
+      end
+    end
+
+    # Are the two accounts of the matching currency as the given amount?
+    #
+    # @return [true, false]
+    def same_currencies?
+      debit_account.currency?(amount.currency) &&
+        credit_account.currency?(amount.currency)
+    end
+
+  end
+end

data/lib/aloe/reports/account_history.rb

@@ -0,0 +1,32 @@
+module Aloe
+  module Reports
+    class AccountHistory
+
+      attr_reader :account
+
+      def initialize(account)
+        @account = account
+      end
+
+      def header
+        ['Transaction', 'Credit', 'Debit', 'Amount', 'Time']
+      end
+
+      def body
+        account.entries.map do |e|
+          tr = e.transaction
+          [tr.category,
+            tr.credit_entry.account.to_s,
+            tr.debit_entry.account.to_s,
+            e.amount.format,
+            e.created_at.to_s]
+        end
+      end
+
+      def footer
+        ['', '', '', account.balance.format, '']
+      end
+
+    end
+  end
+end

data/lib/aloe/reports/accounts_list.rb

@@ -0,0 +1,39 @@
+module Aloe
+  module Reports
+    class AccountsList
+
+      attr_reader :currency
+
+      def initialize(currency = Money.default_currency.to_s)
+        @currency = currency
+      end
+
+      def header
+        ['Type', 'Id', 'Name', 'Owner', 'Currency', 'Balance']
+      end
+
+      def body
+        accounts.map do |a|
+          type = a.name? ? 'System' : 'Entity'
+          [type, a.id, a.name, a.owner_type_and_id, a.currency, a.balance.format]
+        end
+      end
+
+      def footer
+        ['', '', '', '', '', trial_balance.format]
+      end
+
+      protected
+
+      def accounts
+        @accounts ||= Aloe::Account.currency(@currency).all
+      end
+
+      def trial_balance
+        amount = Aloe::Account.trial_balance(@currency)
+        Money.new(amount, @currency)
+      end
+
+    end
+  end
+end

data/lib/aloe/transaction.rb

@@ -0,0 +1,80 @@
+require 'aloe/entry'
+require 'aloe/transaction_rollback'
+require 'active_record'
+require 'uuid'
+
+module Aloe
+  class Transaction < ActiveRecord::Base
+
+    # Associations
+
+    belongs_to :credit_entry, class_name: "Aloe::Entry"
+    has_one    :credit_account, through: :credit_entry, source: :account
+    belongs_to :debit_entry, class_name: "Aloe::Entry"
+    has_one    :debit_account, through: :debit_entry, source: :account
+    belongs_to :adjustment_transaction, class_name: "Transaction"
+    has_one    :adjusted_transaction, class_name: "Transaction",
+                                      foreign_key: "adjustment_transaction_id"
+
+    # Validations
+
+    validates_presence_of :credit_entry
+    validates_presence_of :debit_entry
+    validates_presence_of :category
+
+    # Callbacks
+
+    before_create :assign_uuid
+
+    # Instance methods
+
+    serialize :details
+
+    # Return transaction details hash.
+    #
+    # @return [Hash]
+    def details
+      attributes["details"] ||= {}
+    end
+
+    # Return entries of transaction.
+    #
+    # @return [Array<Aloe::Entry>]
+    def entries
+      [debit_entry, credit_entry]
+    end
+
+    # Return the type of transaction.
+    #
+    # Type of transaction is stored in +category+ attribute
+    # internally because AR uses +type+ for STI.
+    #
+    # @return [Fixnum]
+    def type
+      category
+    end
+
+    # Returns the amount of transaction.
+    #
+    # @return [Money]
+    def amount
+      credit_entry.amount.abs
+    end
+
+    # Rollback transaction by creating balancing entries.
+    def rollback
+      Aloe::TransactionRollback.new(self).rollback!
+    end
+
+    def number
+      uuid.first(8)
+    end
+
+    protected
+
+    def assign_uuid
+      write_attribute :uuid, UUID.new.generate(:compact)
+    end
+
+  end
+end

data/lib/aloe/transaction_rollback.rb

@@ -0,0 +1,34 @@
+module Aloe
+  # Use case class for rolling back a transaction.
+  class TransactionRollback < Struct.new(:transaction)
+
+    def rollback!
+      ActiveRecord::Base.transaction do
+        e1 = credit_entry.account.create_entry debit_entry.amount.cents
+        e2 = debit_entry.account.create_entry credit_entry.amount.cents
+        rollback = Aloe::Transaction.create! credit_entry: e2,
+          debit_entry: e1,
+          category: Aloe::ROLLBACK_TRANSACTION
+        transaction.update_attribute :adjustment_transaction, rollback
+      end
+    end
+
+    private
+
+    # Return credit entry of the transaction.
+    #
+    # @return [Aloe::Entry]
+    def credit_entry
+      transaction.credit_entry
+    end
+
+    # Return debit entry of the transaction.
+    #
+    # @return [Aloe::Entry]
+    def debit_entry
+      transaction.debit_entry
+    end
+
+  end
+end
+

data/lib/aloe/version.rb

@@ -0,0 +1,3 @@
+module Aloe
+  VERSION = '0.1.0'
+end

data/lib/generators/aloe/aloe_generator.rb

@@ -0,0 +1,17 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+class AloeGenerator < Rails::Generators::Base
+
+  include Rails::Generators::Migration
+  source_root File.expand_path('../templates', __FILE__)
+
+  def self.next_migration_number(path)
+    Time.now.utc.strftime("%Y%m%d%H%M%S")
+  end
+
+  def create_migration_file
+    migration_template 'migration.rb', 'db/migrate/create_aloe_tables.rb'
+  end
+end
+

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

@@ -0,0 +1,44 @@
+class CreateAloeTables < ActiveRecord::Migration
+
+  def change
+    create_table :aloe_accounts do |t|
+      t.string :name
+      t.string :currency, limit: 3
+      t.string :state
+      t.text :configuration
+      t.column :balance, :bigint, default: 0
+      t.references :owner, polymorphic: true
+      t.timestamps
+    end
+
+    add_index :aloe_accounts, [:owner_id, :owner_type]
+    add_index :aloe_accounts, :status
+
+    create_table :aloe_entries do |t|
+      t.column :amount, :bigint
+      t.references :account
+      t.timestamps
+    end
+
+    add_index :aloe_entries, :account_id
+
+    create_table :aloe_transactions do |t|
+      t.string :uuid
+      t.string :category
+      t.string :code
+      t.text :description
+      t.text :details
+      t.references :credit_entry
+      t.references :debit_entry
+      t.references :adjustment_transaction
+      t.timestamps
+    end
+
+    add_index :aloe_transactions, :uuid
+    add_index :aloe_transactions, :credit_entry_id
+    add_index :aloe_transactions, :debit_entry_id
+    add_index :aloe_transactions, :adjustment_transaction_id
+    add_index :aloe_transactions, :category
+  end
+
+end

data/lib/tasks/aloe_tasks.rake

@@ -0,0 +1,24 @@
+require 'terminal-table'
+
+task :aloe do
+
+  desc "Show overview of accounts and their balances"
+  task :list_accounts => :environment do
+    currency = ENV["CURRENCY"].presence || Money.default_currency.to_s
+    report = Aloe::Reports::AccountsList.new currency
+    rows = report.body + [:separator] + [report.footer]
+    table = Terminal::Table.new headings: report.header, rows: rows
+    table.align_column(5, :right)
+    puts table
+  end
+
+  desc "Show history of account"
+  task :account_history => :environment do
+    account = Aloe::Account.find ENV["ACCOUNT_ID"]
+    report = Aloe::Reports::AccountHistory.new(account)
+    rows = report.body + [:separator] + [report.footer]
+    table = Terminal::Table.new headings: report.header, rows: rows
+    puts table
+  end
+
+end

data/spec/aloe/account_configuration_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Aloe::AccountConfiguration do
+  describe "#allow_negative_balance" do
+    it "is true by default" do
+      subject.allow_negative_balance.should be_true
+    end
+
+    it "return true if underlying variable is true" do
+      subject.allow_negative_balance = true
+      subject.allow_negative_balance.should be_true
+    end
+
+    it "return false if underlying variable is false" do
+      subject.allow_negative_balance = false
+      subject.allow_negative_balance.should be_false
+    end
+  end
+end

data/spec/aloe/account_integration_spec.rb

@@ -0,0 +1,144 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'timecop'
+
+describe 'Account integration spec', integration: true do
+  let(:owner) { User.create! }
+  let(:owner2) { User.create! }
+
+  describe 'default scope' do
+    before do
+      closed = create_account owner2, :GBP
+      closed.close!
+      @account = create_account owner, :GBP
+    end
+
+    it 'excludes closed account' do
+      Aloe::Account.all.should eq [@account]
+    end
+  end
+
+  describe '#closed scope' do
+    before do
+      @closed = create_account owner2, :GBP
+      @closed.close!
+      account = create_account owner, :GBP
+    end
+
+    it 'includes closed accounts only' do
+      Aloe::Account.closed.should eq [@closed]
+    end
+  end
+
+  describe 'default account state' do
+    let(:account) { Aloe::Account.new }
+
+    it 'is open' do
+      account.state.should eq 'open'
+      account.should be_open
+    end
+  end
+
+  describe 'closing account' do
+    context 'an account with zero balance' do
+      let(:account) { create_account owner, :GBP }
+
+      it 'can be safely closed' do
+        account.close!
+        account.should be_closed
+      end
+    end
+
+    context 'an account with non-zero balance' do
+      let(:account) { create_account owner, :GBP }
+
+      before do
+        account.update_column :balance, 123
+      end
+
+      it 'cannot be closed' do
+        lambda do
+          account.close!
+        end.should raise_error(StateMachine::InvalidTransition)
+        account.should_not be_closed
+        account.should be_open
+      end
+    end
+  end
+
+  describe 'opening closed account' do
+    let(:account) { create_account owner, :GBP }
+
+    before do
+      account.close!
+    end
+
+    it 'can be safely closed' do
+      account.reopen!
+      account.should be_open
+    end
+  end
+
+  describe 'suspending open account' do
+    let(:account) { create_account owner, :GBP }
+
+    it 'can be safely closed' do
+      account.suspend!
+      account.should be_suspended
+    end
+  end
+
+  describe 'unsuspending suspended account' do
+    let(:account) { create_account owner, :GBP }
+
+    before do
+      account.suspend!
+    end
+
+    it 'can be safely closed' do
+      account.unsuspend!
+      account.should be_open
+    end
+  end
+
+  describe '.turnover' do
+    let(:account) { create_account owner, :GBP }
+    let(:amounts1) { [765, 927, 123, -1239, 212, -232] }
+    let(:amounts2) { [23, 123, 145, 7864, -7231] }
+
+    before do
+      account.update_column :created_at, 30.days.ago
+      Timecop.travel(30.days.ago) do
+        amounts1.each { |amount| account.create_entry(amount) }
+      end
+      Timecop.travel(20.days.ago) do
+        amounts2.each { |amount| account.create_entry(amount) }
+      end
+    end
+
+    it 'returns turnover in given period' do
+      account.turnover(21.days.ago..Time.now).should eq Money.new(amounts2.sum, :GBP)
+    end
+  end
+
+  describe '.balance_at' do
+    let(:account) { create_account owner, :GBP }
+    let(:amounts1) { [765, 927, 123, -1239, 212, -232] }
+    let(:amounts2) { [23, 123, 145, 7864, -7231] }
+
+    before do
+      account.update_column :created_at, 30.days.ago
+      Timecop.travel(30.days.ago) do
+        amounts1.each { |amount| account.create_entry(amount) }
+      end
+      Timecop.travel(20.days.ago) do
+        amounts2.each { |amount| account.create_entry(amount) }
+      end
+    end
+
+    it 'returns turnover in given period' do
+      account.balance_at(29.days.ago).should eq Money.new(amounts1.sum, :GBP)
+    end
+  end
+end