double_double 0.0.1

data/lib/double_double/transaction_type.rb

@@ -0,0 +1,13 @@
+module DoubleDouble
+
+  class TransactionType < ActiveRecord::Base
+    self.table_name = 'double_double_transaction_types'
+    
+    has_many :transactions
+    attr_accessible :number, :description
+
+    validates_numericality_of :number,      greater_than: 0
+    validates_length_of       :description, minimum: 6
+  end
+  
+end

data/lib/double_double/version.rb

@@ -0,0 +1,3 @@
+module DoubleDouble
+  VERSION = "0.0.1"
+end

data/lib/double_double.rb

@@ -0,0 +1,21 @@
+require 'active_record'
+require 'money'
+
+require 'double_double/version'
+
+# Accounts
+require 'double_double/account'
+require 'double_double/asset'
+require 'double_double/equity'
+require 'double_double/expense'
+require 'double_double/liability'
+require 'double_double/revenue'
+
+# Amounts
+require 'double_double/amount'
+require 'double_double/credit_amount'
+require 'double_double/debit_amount'
+
+# Transactions
+require 'double_double/transaction'
+require 'double_double/transaction_type'

data/spec/factories/account_factory.rb

@@ -0,0 +1,27 @@
+FactoryGirl.define do
+  factory :account, :class => DoubleDouble::Account do |account|
+    account.name   { FactoryGirl.generate(:account_name)  }
+    account.number { FactoryGirl.generate(:account_number)}
+    account.contra false
+
+    factory :asset,     :class => DoubleDouble::Asset
+    factory :equity,    :class => DoubleDouble::Equity
+    factory :expense,   :class => DoubleDouble::Expense
+    factory :liability, :class => DoubleDouble::Liability
+    factory :revenue,   :class => DoubleDouble::Revenue
+
+    factory :not_asset,     :class => DoubleDouble::Liability
+    factory :not_equity,    :class => DoubleDouble::Asset
+    factory :not_expense,   :class => DoubleDouble::Liability
+    factory :not_liability, :class => DoubleDouble::Asset
+    factory :not_revenue,   :class => DoubleDouble::Asset
+  end
+  
+  sequence :account_name do |n|
+    "account name #{n}"
+  end
+
+  sequence :account_number do |n|
+    8000 + n
+  end
+end

data/spec/factories/amount_factory.rb

@@ -0,0 +1,10 @@
+FactoryGirl.define do
+  factory :amount, :class => DoubleDouble::Amount do |amount|
+  end
+
+  factory :credit_amt, :class => DoubleDouble::CreditAmount  do
+  end
+
+  factory :debit_amt, :class => DoubleDouble::DebitAmount  do
+  end
+end

data/spec/factories/transaction_factory.rb

@@ -0,0 +1,9 @@
+FactoryGirl.define do
+  factory :transaction, :class => DoubleDouble::Transaction do
+    description { FactoryGirl.generate(:transaction_type_description) }
+  end
+
+  sequence :transaction_description do |n|
+    "transaction description #{n}"
+  end
+end

data/spec/factories/transaction_type_factory.rb

@@ -0,0 +1,14 @@
+FactoryGirl.define do
+  factory :transaction_type, :class => DoubleDouble::TransactionType do |type|
+    type.description  { FactoryGirl.generate(:transaction_type_description) }
+    type.number       { FactoryGirl.generate(:transaction_type_number)      }
+  end
+
+  sequence :transaction_type_description do |n|
+    "transaction type description #{n}"
+  end
+
+  sequence :transaction_type_number do |n|
+    9000 + n
+  end
+end

data/spec/models/account_spec.rb

@@ -0,0 +1,70 @@
+module DoubleDouble
+  describe Account do
+
+    it "should not allow creating an account without a subtype" do
+      account = FactoryGirl.build(:account)
+      account.should_not be_valid
+    end
+
+    it "should be unique per name" do
+      FactoryGirl.create(:asset, :name => "Test1")
+      account = FactoryGirl.build(:asset, :name => "Test1")
+      account.should_not be_valid
+      account.errors[:name].should == ["has already been taken"]
+    end
+    
+    it "should be unique per number" do
+      FactoryGirl.create(:asset, :number => 88)
+      account = FactoryGirl.build(:asset, :number => 88)
+      account.should_not be_valid
+      account.errors[:number].should == ["has already been taken"]
+    end
+
+    it "should not have a balance method" do
+      lambda{Account.balance}.should raise_error(NoMethodError)
+    end
+
+    it "should have a trial balance" do
+      Account.should respond_to(:trial_balance)
+      Account.trial_balance.should be_kind_of(Money)
+    end
+
+    it "should report a trial balance of 0 with correct transactions (with a contrived example of transactions)" do
+      # credit accounts
+      liability      = FactoryGirl.create(:liability)
+      equity         = FactoryGirl.create(:equity)
+      revenue        = FactoryGirl.create(:revenue)
+      contra_asset   = FactoryGirl.create(:asset, :contra => true)
+      contra_expense = FactoryGirl.create(:expense, :contra => true)
+      # debit accounts
+      asset            = FactoryGirl.create(:asset)
+      expense          = FactoryGirl.create(:expense)
+      contra_liability = FactoryGirl.create(:liability, :contra => true)
+      contra_equity    = FactoryGirl.create(:equity, :contra => true)
+      contra_revenue   = FactoryGirl.create(:revenue, :contra => true)
+
+      t = FactoryGirl.build(:transaction)
+      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: 100_000, account: liability)
+      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: 100_000, account: asset)
+      t.save
+      t = FactoryGirl.build(:transaction)
+      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: 1_000, account: equity)
+      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: 1_000, account: expense)
+      t.save
+      t = FactoryGirl.build(:transaction)
+      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: 40_404, account: revenue)
+      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: 40_404, account: contra_liability)
+      t.save
+      t = FactoryGirl.build(:transaction)
+      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: 2, account: contra_asset)
+      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: 2, account: contra_equity)
+      t.save
+      t = FactoryGirl.build(:transaction)
+      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: 333, account: contra_expense)
+      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: 333, account: contra_revenue)
+      t.save
+
+      Account.trial_balance.should == 0
+    end
+  end
+end

data/spec/models/amount_spec.rb

@@ -0,0 +1,9 @@
+module DoubleDouble
+  describe Amount do
+
+    it "should not allow creating an amount without a subtype" do
+      amount = FactoryGirl.build(:amount)
+      amount.should_not be_valid
+    end
+  end
+end

data/spec/models/asset_spec.rb

@@ -0,0 +1,12 @@
+module DoubleDouble
+  describe Asset do
+    
+    it_behaves_like "all account types" do
+      let(:account_type) {:asset}
+    end
+
+    it_behaves_like "a left side account type" do
+      let(:left_side_account_type) {:asset}
+    end
+  end
+end

data/spec/models/credit_amount_spec.rb

@@ -0,0 +1,46 @@
+module DoubleDouble
+  describe CreditAmount do
+
+    it "should not be valid without an amount" do
+      expect {
+        FactoryGirl.build(:credit_amt, amount: nil, transaction: FactoryGirl.build(:transaction))
+      }.to raise_error(ArgumentError)
+    end
+
+    it "should not be valid without a transaction" do
+      acct = FactoryGirl.create(:asset)
+      credit_amount = FactoryGirl.build(:credit_amt, transaction: nil, account: acct, amount: Money.new(20))
+      credit_amount.should_not be_valid
+    end
+
+    it "should not be valid without an account" do
+      t = FactoryGirl.build(:transaction)
+      credit_amount = FactoryGirl.build(:credit_amt, account: nil, transaction: t, amount: Money.new(20))
+      credit_amount.should_not be_valid
+    end
+    
+    it "should be sensitive to project_id when calculating balances, if supplied" do
+      acct_1     = FactoryGirl.create(:asset)
+      other_acct = FactoryGirl.create(:not_asset)
+      t = FactoryGirl.build(:transaction)
+      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(123), account: acct_1, project_id: 77)
+      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(123), account: other_acct)
+      t.save
+      t = FactoryGirl.build(:transaction)
+      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(321), account: acct_1, project_id: 77)
+      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(321), account: other_acct)
+      t.save
+      t = FactoryGirl.build(:transaction)
+      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(275), account: acct_1, project_id: 82)
+      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(275), account: other_acct)
+      t.save
+      t = FactoryGirl.build(:transaction)
+      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(999), account: acct_1)
+      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(999), account: other_acct)
+      t.save
+      acct_1.credits_balance({project_id: 77}).should == Money.new(123 + 321)
+      acct_1.credits_balance({project_id: 82}).should == Money.new(275)
+      acct_1.credits_balance.should                   == Money.new(123 + 321 + 275 + 999)
+    end
+  end
+end

data/spec/models/debit_amount_spec.rb

@@ -0,0 +1,46 @@
+module DoubleDouble
+  describe DebitAmount do
+
+    it "should not be valid without an amount" do
+      expect {
+        FactoryGirl.build(:debit_amt, amount: nil, transaction: FactoryGirl.build(:transaction))
+      }.to raise_error(ArgumentError)
+    end
+
+    it "should not be valid without a transaction" do
+      acct = FactoryGirl.create(:asset)
+      debit_amount = FactoryGirl.build(:debit_amt, transaction: nil, account: acct, amount: Money.new(20))
+      debit_amount.should_not be_valid
+    end
+
+    it "should not be valid without an account" do
+      t = FactoryGirl.build(:transaction)
+      debit_amount = FactoryGirl.build(:debit_amt, account: nil, transaction: t, amount: Money.new(20))
+      debit_amount.should_not be_valid
+    end
+    
+    it "should be sensitive to project_id when calculating balances, if supplied" do
+      acct_1     = FactoryGirl.create(:asset)
+      other_acct = FactoryGirl.create(:not_asset)
+      t = FactoryGirl.build(:transaction)
+      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(123), account: acct_1, project_id: 77)
+      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(123), account: other_acct)
+      t.save
+      t = FactoryGirl.build(:transaction)
+      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(321), account: acct_1, project_id: 77)
+      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(321), account: other_acct)
+      t.save
+      t = FactoryGirl.build(:transaction)
+      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(275), account: acct_1, project_id: 82)
+      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(275), account: other_acct)
+      t.save
+      t = FactoryGirl.build(:transaction)
+      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(999), account: acct_1)
+      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(999), account: other_acct)
+      t.save
+      acct_1.debits_balance({project_id: 77}).should == Money.new(123 + 321)
+      acct_1.debits_balance({project_id: 82}).should == Money.new(275)
+      acct_1.debits_balance.should                   == Money.new(123 + 321 + 275 + 999)
+    end
+  end
+end

data/spec/models/equity_spec.rb

@@ -0,0 +1,12 @@
+module DoubleDouble
+  describe Equity do
+    
+    it_behaves_like "all account types" do
+      let(:account_type) {:equity}
+    end
+
+    it_behaves_like "a right side account type" do
+      let(:right_side_account_type) {:equity}
+    end
+  end
+end

data/spec/models/expense_spec.rb

@@ -0,0 +1,12 @@
+module DoubleDouble
+  describe Expense do
+
+    it_behaves_like "all account types" do
+      let(:account_type) {:expense}
+    end
+
+    it_behaves_like "a left side account type" do
+      let(:left_side_account_type) {:expense}
+    end
+  end
+end

data/spec/models/liability_spec.rb

@@ -0,0 +1,12 @@
+module DoubleDouble
+  describe Liability do
+
+    it_behaves_like "all account types" do
+      let(:account_type) {:liability}
+    end
+
+    it_behaves_like "a right side account type" do
+      let(:right_side_account_type) {:liability}
+    end
+  end
+end

data/spec/models/revenue_spec.rb

@@ -0,0 +1,12 @@
+module DoubleDouble
+  describe Revenue do
+
+    it_behaves_like "all account types" do
+      let(:account_type) {:revenue}
+    end
+
+    it_behaves_like "a right side account type" do
+      let(:right_side_account_type) {:revenue}
+    end
+  end
+end

data/spec/models/transaction_spec.rb

@@ -0,0 +1,101 @@
+module DoubleDouble
+  describe Transaction do
+
+    before(:each) do
+      @acct       = FactoryGirl.create(:asset)
+      @other_acct = FactoryGirl.create(:not_asset)
+    end
+
+    it "should create a transaction" do
+      -> {
+        t = FactoryGirl.build(:transaction)
+        t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(123), account: @acct)
+        t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(123), account: @other_acct)
+        t.save!
+      }.should change(DoubleDouble::Transaction, :count).by(1)
+    end
+
+    it "should not be valid without a credit amount" do
+      t = FactoryGirl.build(:transaction)
+      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(123), account: @other_acct)
+      t.should_not be_valid
+      t.errors['base'].should include("Transaction must have at least one credit amount")
+    end
+
+    it "should not be valid with an invalid credit amount" do
+      -> {
+        t = FactoryGirl.build(:transaction)
+        t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: nil,            account: @acct)
+        t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(123), account: @other_acct)
+        t.save
+      }.should raise_error(ArgumentError)
+    end
+
+    it "should not be valid without a debit amount" do
+      t = FactoryGirl.build(:transaction)
+      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(123), account: @acct)
+      t.should_not be_valid
+      t.errors['base'].should include("Transaction must have at least one debit amount")
+    end
+
+    it "should not be valid with an invalid debit amount" do
+      -> {
+        t = FactoryGirl.build(:transaction)
+        t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(123), account: @acct)
+        t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: nil,            account: @other_acct)
+        t.save
+      }.should raise_error(ArgumentError)
+    end
+
+    it "should not be valid without a description" do
+      t = FactoryGirl.build(:transaction, description: nil)
+      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(123), account: @acct)
+      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(123), account: @other_acct)
+      t.save
+      t.should_not be_valid
+      t.errors[:description].should == ["can't be blank"]
+    end
+
+    it "should require the debit and credit amounts to cancel" do
+      t = FactoryGirl.build(:transaction)
+      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(555), account: @acct)
+      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(666), account: @other_acct)
+      t.save
+      t.should_not be_valid
+      t.errors['base'].should == ["The credit and debit amounts are not equal"]
+    end
+
+    it "should have a polymorphic commercial document associations" do
+      mock_document = FactoryGirl.create(:asset) # one would never do this, but it allows us to not require a migration for the test
+
+      t = FactoryGirl.build(:transaction)
+      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: Money.new(123), account: @acct)
+      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: Money.new(123), account: @other_acct)
+      t.commercial_document = mock_document
+      t.save
+
+      saved_transaction = Transaction.find(t.id)
+      saved_transaction.commercial_document.should == mock_document
+    end
+
+    it "should allow building a transaction and credit and debits with a hash" do
+      FactoryGirl.create(:asset, :name => "Accounts Receivable")
+      FactoryGirl.create(:revenue, :name => "Sales Revenue")
+      FactoryGirl.create(:liability, :name =>  "Sales Tax Payable")
+      mock_document = FactoryGirl.create(:asset)
+      transaction = Transaction.build(
+        description: "Sold some widgets",
+        commercial_document: mock_document,
+        debits: [
+          {account: "Accounts Receivable", amount: 50}], 
+        credits: [
+          {account: "Sales Revenue", amount: 45},
+          {account: "Sales Tax Payable", amount: 5}])
+      transaction.should be_valid
+      transaction.save
+      saved_transaction = DoubleDouble::Transaction.find(transaction.id)
+      saved_transaction.commercial_document.should == mock_document
+    end
+
+  end
+end