double_double 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.DS_Store
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format progress
+-r ./spec/spec_helper.rb

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - jruby-19mode
+  - rbx-19mode
+  - ruby-head
+env:
+  - JRUBY_OPTS="--1.9"
+script: rake

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in double_double.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Mike Herrera
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,38 @@
+# double_double
+[![Build Status](https://travis-ci.org/crftr/double_double.png)](https://travis-ci.org/crftr/double_double)
+
+A double-entry accounting system.  Likely to change heavily in the coming days.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'double_double'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install double_double
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Name
+
+The double double is the flagship In-N-Out cheeseburger.  Ask a southern-Californian.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Notes
+
+double_double was heavily influenced by mbulat's plutus project and regularly working with quickbooks.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+desc 'run specs'
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ["--color", "--format progress", "-r ./spec/spec_helper.rb"]
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+task default: :spec

data/double_double.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'double_double/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'double_double'
+  gem.version       = DoubleDouble::VERSION
+  gem.authors       = ['Mike Herrera']
+  gem.email         = ['git@devoplabs.com']
+  gem.description   = %q{A double-entry accural accounting system}
+  gem.summary       = %q{A double-entry accural accounting system. All currency amounts are stored using the Money gem.}
+  gem.homepage      = 'https://github.com/crftr/double_double'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features|account_types)/})
+  gem.require_paths = ['lib']
+
+  gem.add_dependency('money', '~> 5.1')
+  gem.add_dependency 'activerecord', '~> 3.2.11'
+  gem.add_development_dependency('sqlite3')
+  gem.add_development_dependency('rspec', '~> 2.12')
+  gem.add_development_dependency('factory_girl')
+  gem.add_development_dependency('database_cleaner')
+  gem.add_development_dependency('pry')
+end

data/lib/double_double/account.rb

@@ -0,0 +1,85 @@
+module DoubleDouble
+  # The Account class represents accounts in the system. Each account must be subclassed as one of the following types:
+  #
+  #   TYPE        | NORMAL BALANCE    | DESCRIPTION
+  #   --------------------------------------------------------------------------
+  #   Asset       | Debit             | Resources owned by the Business Entity
+  #   Liability   | Credit            | Debts owed to outsiders
+  #   Equity      | Credit            | Owners rights to the Assets
+  #   Revenue     | Credit            | Increases in owners equity
+  #   Expense     | Debit             | Assets or services consumed in the generation of revenue
+  #
+  # Each account can also be marked as a "Contra Account". A contra account will have it's
+  # normal balance swapped. For example, to remove equity, a "Drawing" account may be created
+  # as a contra equity account as follows:
+  #
+  #   DoubleDouble::Equity.create(:name => "Drawing", contra => true)
+  #
+  # At all times the balance of all accounts should conform to the "accounting equation"
+  #   DoubleDouble::Assets = Liabilties + Owner's Equity
+  #
+  # Each sublclass account acts as it's own ledger. See the individual subclasses for a
+  # description.
+  #
+  # @abstract
+  #   An account must be a subclass to be saved to the database. The Account class
+  #   has a singleton method {trial_balance} to calculate the balance on all Accounts.
+  #
+  # @see http://en.wikipedia.org/wiki/Accounting_equation Accounting Equation
+  # @see http://en.wikipedia.org/wiki/Debits_and_credits Debits, Credits, and Contra Accounts
+  #
+  class Account < ActiveRecord::Base
+    self.table_name = 'double_double_accounts'
+
+    attr_accessible :name, :contra, :number
+    
+    has_many :credit_amounts
+    has_many :debit_amounts
+    has_many :credit_transactions, :through => :credit_amounts, :source => :transaction
+    has_many :debit_transactions, :through => :debit_amounts, :source => :transaction
+
+    validates_presence_of :type, :name, :number
+    validates_uniqueness_of :name, :number
+
+    def side_balance(is_debit, hash)
+      a = is_debit ? DoubleDouble::DebitAmount.scoped : DoubleDouble::CreditAmount.scoped
+      a = a.where(account_id: self.id)
+      a = a.by_project_id( hash[:project_id] )               if hash.has_key?(:project_id)
+      a = a.by_approving_user_id( hash[:approving_user_id] ) if hash.has_key?(:approving_user_id)
+      a = a.by_targeted_user_id( hash[:targeted_user_id] )   if hash.has_key?(:targeted_user_id)
+      Money.new(a.sum(:amount_cents))
+    end
+    
+    def credits_balance(hash = {})
+      side_balance(false, hash)
+    end
+
+    def debits_balance(hash = {})
+      side_balance(true, hash)
+    end
+
+    # The trial balance of all accounts in the system. This should always equal zero,
+    # otherwise there is an error in the system.
+    #
+    # @return [Money] The value balance of all accounts
+    def self.trial_balance
+      raise(NoMethodError, "undefined method 'trial_balance'") unless self.new.class == DoubleDouble::Account
+      Asset.balance - (Liability.balance + Equity.balance + Revenue.balance - Expense.balance)
+    end
+    
+    def self.balance
+      raise(NoMethodError, "undefined method 'balance'") if self.new.class == DoubleDouble::Account
+      accounts_balance = Money.new(0)
+      accounts = self.all
+      accounts.each do |acct|
+        if acct.contra
+          accounts_balance -= acct.balance
+        else
+          accounts_balance += acct.balance
+        end
+      end
+      accounts_balance
+    end
+    
+  end
+end

data/lib/double_double/amount.rb

@@ -0,0 +1,33 @@
+module DoubleDouble
+  # The Amount class represents debit and credit amounts in the system.
+  #
+  # @abstract
+  #   An amount must be a subclass as either a debit or a credit to be saved to the database. 
+  #
+  class Amount < ActiveRecord::Base
+    self.table_name = 'double_double_amounts'
+
+    attr_accessible :account, :amount, :transaction, :project_id, :approving_user_id, :targeted_user_id
+    
+    belongs_to :transaction
+    belongs_to :account
+    belongs_to :project
+    belongs_to :approving_user, :class_name => "User"
+    belongs_to :targeted_user,  :class_name => "User"
+    
+    scope :by_project_id,        lambda{|p_id| where(:project_id => p_id)}
+    scope :by_approving_user_id, lambda{|au_id| where(:approving_user_id => au_id)}
+    scope :by_targeted_user_id,  lambda{|tu_id| where(:targeted_user_id => tu_id)}
+
+    scope :by_transaction_type_number, lambda{|tt_num| where( transaction: {transaction_type: {number: tt_num}})}
+
+    validates_presence_of :type, :amount_cents, :transaction, :account
+    
+    composed_of :amount,
+      :class_name => "Money",
+      :mapping => [%w(amount_cents cents), %w(currency currency_as_string)],
+      :constructor => Proc.new { |cents, currency| Money.new(cents || 0, currency || Money.default_currency) },
+      :converter => Proc.new { |value| value.respond_to?(:to_money) ? value.to_money : raise(ArgumentError, "Can't convert #{value.class} to Money") }
+    
+  end
+end

data/lib/double_double/asset.rb

@@ -0,0 +1,25 @@
+module DoubleDouble
+  # The Asset class is an account type used to represents resources owned by the business entity.
+  #
+  # === Normal Balance
+  # The normal balance on Asset accounts is a *Debit*.
+  #
+  # @see http://en.wikipedia.org/wiki/Asset Assets
+  #
+  class Asset < Account
+
+    # The balance of the account.
+    #
+    # Assets have normal debit balances, so the credits are subtracted from the debits
+    # unless this is a contra account, in which debits are subtracted from credits
+    #
+    # @return [Money] The value balance
+    def balance(hash = {})
+      if contra
+        credits_balance(hash) - debits_balance(hash)
+      else
+        debits_balance(hash) - credits_balance(hash)
+      end
+    end
+  end
+end

data/lib/double_double/credit_amount.rb

@@ -0,0 +1,9 @@
+module DoubleDouble
+  # The CreditAmount class represents credit entries in the transaction journal.
+  #
+  # @example
+  #     credit_amount = DoubleDouble::CreditAmount.new(:account => revenue, :amount => 1000)
+  #
+  class CreditAmount < Amount
+  end
+end

data/lib/double_double/debit_amount.rb

@@ -0,0 +1,9 @@
+module DoubleDouble
+  # The DebitAmount class represents debit entries in the transaction journal.
+  #
+  # @example
+  #     debit_amount = DoubleDouble::DebitAmount.new(:account => cash, :amount => 1000)
+  #
+  class DebitAmount < Amount
+  end
+end

data/lib/double_double/equity.rb

@@ -0,0 +1,26 @@
+module DoubleDouble
+  # The Equity class is an account type used to represents owners rights to the assets.
+  #
+  # === Normal Balance
+  # The normal balance on Equity accounts is a *Credit*.
+  #
+  # @see http://en.wikipedia.org/wiki/Equity_(finance) Equity
+  #
+  # @author Michael Bulat
+  class Equity < Account
+
+    # The balance of the account.
+    #
+    # Equity accounts have normal credit balances, so the debits are subtracted from the credits
+    # unless this is a contra account, in which credits are subtracted from debits
+    #
+    # @return [Money] The value balance
+    def balance(hash = {})
+      if contra
+        debits_balance(hash) - credits_balance(hash)
+      else
+        credits_balance(hash) - debits_balance(hash)
+      end
+    end
+  end
+end

data/lib/double_double/expense.rb

@@ -0,0 +1,26 @@
+module DoubleDouble
+  # The Expense class is an account type used to represents assets or services consumed in the generation of revenue.
+  #
+  # === Normal Balance
+  # The normal balance on Expense accounts is a *Debit*.
+  #
+  # @see http://en.wikipedia.org/wiki/Expense Expenses
+  #
+  # @author Michael Bulat
+  class Expense < Account
+
+    # The balance of the account.
+    #
+    # Expenses have normal debit balances, so the credits are subtracted from the debits
+    # unless this is a contra account, in which debits are subtracted from credits
+    #
+    # @return [Money] The value balance
+    def balance(hash = {})
+      if contra
+        credits_balance(hash) - debits_balance(hash)
+      else
+        debits_balance(hash) - credits_balance(hash)
+      end
+    end
+  end
+end

data/lib/double_double/liability.rb

@@ -0,0 +1,25 @@
+module DoubleDouble
+  # The Liability class is an account type used to represents debts owed to outsiders.
+  #
+  # === Normal Balance
+  # The normal balance on Liability accounts is a *Credit*.
+  #
+  # @see http://en.wikipedia.org/wiki/Liability_(financial_accounting) Liability
+  #
+  class Liability < Account
+
+    # The balance of the account.
+    #
+    # Liability accounts have normal credit balances, so the debits are subtracted from the credits
+    # unless this is a contra account, in which credits are subtracted from debits
+    #
+    # @return [Money] The value balance
+    def balance(hash = {})
+      if contra
+        debits_balance(hash) - credits_balance(hash)
+      else
+        credits_balance(hash) - debits_balance(hash)
+      end
+    end
+  end
+end

data/lib/double_double/revenue.rb

@@ -0,0 +1,26 @@
+module DoubleDouble
+  # The Revenue class is an account type used to represents increases in owners equity.
+  #
+  # === Normal Balance
+  # The normal balance on Revenue accounts is a *Credit*.
+  #
+  # @see http://en.wikipedia.org/wiki/Revenue Revenue
+  #
+  # @author Michael Bulat
+  class Revenue < Account
+
+    # The balance of the account.
+    #
+    # Revenue accounts have normal credit balances, so the debits are subtracted from the credits
+    # unless this is a contra account, in which credits are subtracted from debits
+    #
+    # @return [Money] The value balance
+    def balance(hash = {})
+      if contra
+        debits_balance(hash) - credits_balance(hash)
+      else
+        credits_balance(hash) - debits_balance(hash)
+      end
+    end
+  end
+end

data/lib/double_double/transaction.rb

@@ -0,0 +1,88 @@
+module DoubleDouble
+  # Transactions are the recording of debits and credits to various accounts.
+  # This table can be thought of as a traditional accounting Journal.
+  #
+  # Posting to a Ledger can be considered to happen automatically, since
+  # Accounts have the reverse 'has_many' relationship to either it's credit or
+  # debit transactions
+  #
+  # @example
+  #   cash = DoubleDouble::Asset.find_by_name('Cash')
+  #   accounts_receivable = DoubleDouble::Asset.find_by_name('Accounts Receivable')
+  #
+  #   debit_amount = DoubleDouble::DebitAmount.new(:account => cash, :amount => 1000)
+  #   credit_amount = DoubleDouble::CreditAmount.new(:account => accounts_receivable, :amount => 1000)
+  #
+  #   transaction = DoubleDouble::Transaction.new(:description => "Receiving payment on an invoice")
+  #   transaction.debit_amounts << debit_amount
+  #   transaction.credit_amounts << credit_amount
+  #   transaction.save
+  #
+  # @see http://en.wikipedia.org/wiki/Journal_entry Journal Entry
+  #
+  class Transaction < ActiveRecord::Base
+    self.table_name = 'double_double_transactions'
+
+    attr_accessible :description, :commercial_document
+
+    belongs_to :transaction_type
+    belongs_to :commercial_document, :polymorphic => true
+
+    has_many :credit_amounts
+    has_many :debit_amounts
+    has_many :credit_accounts, :through => :credit_amounts, :source => :account
+    has_many :debit_accounts, :through => :debit_amounts, :source => :account
+
+    validates_presence_of :description
+    validate :has_credit_amounts?
+    validate :has_debit_amounts?
+    validate :amounts_cancel?
+
+    scope :by_transaction_type_number, lambda{|tt_num| where(transaction_type: {number: tt_num})}
+
+    # Simple API for building a transaction and associated debit and credit amounts
+    #
+    # @example
+    #   transaction = DoubleDouble::Transaction.build(
+    #     description: "Sold some widgets",
+    #     debits: [
+    #       {account: "Accounts Receivable", amount: 50}], 
+    #     credits: [
+    #       {account: "Sales Revenue", amount: 45},
+    #       {account: "Sales Tax Payable", amount: 5}])
+    #
+    # @return [DoubleDouble::Transaction] A Transaction with built credit and debit objects ready for saving
+    def self.build(hash)
+      transaction = Transaction.new(description: hash[:description], commercial_document: hash[:commercial_document])
+      hash[:debits].each do |debit|
+        a = Account.find_by_name(debit[:account])
+        transaction.debit_amounts << DebitAmount.new(account: a, amount: debit[:amount], transaction: transaction, project_id: debit[:project_id], approving_user_id: debit[:approving_user_id], targeted_user_id: debit[:targeted_user_id])
+      end
+      hash[:credits].each do |credit|
+        a = Account.find_by_name(credit[:account])
+        transaction.credit_amounts << CreditAmount.new(account: a, amount: credit[:amount], transaction: transaction, project_id: credit[:project_id], approving_user_id: credit[:approving_user_id], targeted_user_id: credit[:targeted_user_id])
+      end
+      transaction.transaction_type = hash[:transaction_type] if hash.has_key?(:transaction_type)
+      transaction
+    end
+
+    private
+      def has_credit_amounts?
+        errors[:base] << "Transaction must have at least one credit amount" if self.credit_amounts.blank?
+      end
+
+      def has_debit_amounts?
+        errors[:base] << "Transaction must have at least one debit amount" if self.debit_amounts.blank?
+      end
+
+      def amounts_cancel?
+        errors[:base] << "The credit and debit amounts are not equal" if difference_of_amounts != 0
+      end
+
+      def difference_of_amounts
+        credit_amount_total = credit_amounts.inject(Money.new(0)) {|sum, credit_amount| sum + credit_amount.amount}
+        debit_amount_total  = debit_amounts.inject(Money.new(0))  {|sum, debit_amount|  sum + debit_amount.amount}
+        credit_amount_total - debit_amount_total
+      end
+  end
+end