double_double 0.2.0 → 0.2.3

data/README.md

@@ -33,8 +33,8 @@ Edit the migration to match:
 class CreateDoubleDouble < ActiveRecord::Migration
   def change
     create_table :double_double_accounts do |t|
-      t.string  :name,          null: false
       t.integer :number,        null: false
+      t.string  :name,          null: false
       t.string  :type,          null: false
       t.boolean :contra,        default: false
     end
@@ -42,31 +42,31 @@ class CreateDoubleDouble < ActiveRecord::Migration
 
     create_table :double_double_transactions do |t|
       t.string :description
+      t.references :initiator,        polymorphic: true
       t.references :transaction_type
       t.timestamps
     end
+    add_index :double_double_transactions, :initiator_id
+    add_index :double_double_transactions, :initiator_type
     add_index :double_double_transactions, :transaction_type_id
 
     create_table :double_double_transaction_types do |t|
-      t.integer :number,        null: false
       t.string :description,    null: false
     end
-    add_index :double_double_transaction_types, :number
+    add_index :double_double_transaction_types, :description
 
     create_table :double_double_amounts do |t|
       t.string :type
       t.references :account
       t.references :transaction
-      t.references :accountee,  polymorphic: true
       t.references :context,    polymorphic: true
-      t.references :initiator,  polymorphic: true
+      t.references :accountee,  polymorphic: true
+      
       t.integer :amount_cents, limit: 8, default: 0, null: false
       t.string  :currency
     end
     add_index :double_double_amounts, :context_id
     add_index :double_double_amounts, :context_type
-    add_index :double_double_amounts, :initiator_id
-    add_index :double_double_amounts, :initiator_type
     add_index :double_double_amounts, :accountee_id
     add_index :double_double_amounts, :accountee_type
     add_index :double_double_amounts, :type
@@ -144,13 +144,15 @@ Contra accounts are used to offset a related account of the same class.  *The ex
 
 #### Basic Scenario: We are creating a personal application to only track loan payments back to Grandpa.  
 
-We've decided to keep things very simple and only create two accounts:
+We've decided to keep things very simple and only create a few accounts:
 * 'Cash' an asset account.
 * 'Grandpa Loan' a liability account.
+* 'Spending' an expense account
 
 ```ruby
 DoubleDouble::Asset.create! name:'Cash', number: 11
 DoubleDouble::Liability.create! name:'Grandpa Loan', number: 12
+DoubleDouble::Expense.create! name:'Spending', number: 13
 ```
 Grandpa was kind enough to loan us $800 USD in cash for college textbooks.  To enter this we will require a transaction which will affect both 'Cash' and 'Grandpa Loan'
 ```ruby
@@ -162,7 +164,23 @@ DoubleDouble::Transaction.create!(
   credits:[
     {account: 'Grandpa Loan', amount: '$800'}])
 ```
-But because we were surprised to have the option to buy a few used textbooks we can return some of Grandpa's loan.  We will return $320.
+We buy our college textbooks.
+
+```ruby
+DoubleDouble::Transaction.create!(
+  description: 
+    'Purchase textbooks from bookstore',
+  debits:[
+    {account: 'Spending', amount: '$480'}],
+  credits:[
+    {account: 'Cash', amount: '$480'}])
+```
+How much cash is left?
+
+```ruby
+DoubleDouble::Account.named('Cash').balance.to_s           # => "320.00"
+```
+We deceided that we wanted to return $320 of the loan.
 ```ruby
 DoubleDouble::Transaction.create!(
   description: 
@@ -172,10 +190,19 @@ DoubleDouble::Transaction.create!(
   credits:[
     {account: 'Cash', amount: '$320'}])
 ```
-If we want to know how much we still owed Grandpa we can look at the balance of the account.
+How much do we still owe Grandpa?
 ```ruby
-DoubleDouble::Account.find_by_name('Grandpa Loan').balance.to_s    # => "480.00"
+DoubleDouble::Account.named('Grandpa Loan').balance.to_s   # => "480.00"
 ```
+How much did we spend?
+```ruby
+DoubleDouble::Account.named('Spending').balance.to_s       # => "480.00"
+```
+How much cash do we have left?
+```ruby
+DoubleDouble::Account.named('Cash').balance.to_s           # => "0.00"
+```
+
 
 ### Realistic Scenarios
 * TODO: Write a realistic scenario

data/double_double.gemspec

@@ -17,11 +17,13 @@ Gem::Specification.new do |gem|
   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')
+  gem.required_ruby_version = '>= 1.9.2'
+
+  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

@@ -42,15 +42,30 @@ module DoubleDouble
     validates_uniqueness_of :name, :number
     validates_length_of :name, :minimum => 1
 
-    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_context(hash[:context])     if hash.has_key? :context
-      a = a.by_initiator(hash[:initiator]) if hash.has_key? :initiator
-      a = a.by_accountee(hash[:accountee]) if hash.has_key? :accountee
-      Money.new(a.sum(:amount_cents))
+    class << self
+      # 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 trial_balance
+        raise(NoMethodError, "undefined method 'trial_balance'") unless self == DoubleDouble::Account
+        Asset.balance - (Liability.balance + Equity.balance + Revenue.balance - Expense.balance)
+      end
+      
+      def balance
+        raise(NoMethodError, "undefined method 'balance'") if self == DoubleDouble::Account
+        accounts_balance = self.all.inject(Money.new(0)) {|sum, acct| acct.contra ? (sum - acct.balance) : (sum + acct.balance)}
+      end
+
+      def named account_name
+        self.where(name: account_name.to_s).first
+      end
+
+      def numbered account_number
+        self.where(number: account_number.to_i).first
+      end
     end
-    
+
     def credits_balance(hash = {})
       side_balance(false, hash)
     end
@@ -59,30 +74,15 @@ module DoubleDouble
       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 == DoubleDouble::Account
-      Asset.balance - (Liability.balance + Equity.balance + Revenue.balance - Expense.balance)
-    end
-    
-    def self.balance
-      raise(NoMethodError, "undefined method 'balance'") if self == 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
-
     protected
+
+      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_context(hash[:context])     if hash.has_key? :context
+        a = a.by_accountee(hash[:accountee]) if hash.has_key? :accountee
+        Money.new(a.sum(:amount_cents))
+      end
       # The balance method that derived Accounts utilize.
       #
       # Nornal Debit Accounts:

data/lib/double_double/amount.rb

@@ -13,13 +13,9 @@ module DoubleDouble
     belongs_to :account
     belongs_to :accountee,  polymorphic: true
     belongs_to :context,    polymorphic: true
-    belongs_to :initiator,  polymorphic: true
     
     scope :by_accountee, ->(a) { where(accountee_id: a.id, accountee_type: a.class.base_class) }
     scope :by_context,   ->(c) { where(context_id:   c.id, context_type:   c.class.base_class) }
-    scope :by_initiator, ->(i) { where(initiator_id: i.id, initiator_type: i.class.base_class) }
-
-    # scope :by_transaction_type_number, -> {|tt_num| where( transaction: {transaction_type: {number: tt_num}})}
 
     validates_presence_of :type, :transaction, :account
     validates :amount_cents, numericality: {greater_than: 0}

data/lib/double_double/transaction.rb

@@ -7,8 +7,8 @@ module DoubleDouble
   # debit transactions
   #
   # @example
-  #   cash = DoubleDouble::Asset.find_by_name('Cash')
-  #   accounts_receivable = DoubleDouble::Asset.find_by_name('Accounts Receivable')
+  #   cash = DoubleDouble::Asset.named('Cash')
+  #   accounts_receivable = DoubleDouble::Asset.named('Accounts Receivable')
   #
   #   debit_amount = DoubleDouble::DebitAmount.new(account: 'cash', amount: 1000)
   #   credit_amount = DoubleDouble::CreditAmount.new(account: 'accounts_receivable', amount: 1000)
@@ -26,6 +26,7 @@ module DoubleDouble
     attr_accessible :description
 
     belongs_to :transaction_type
+    belongs_to :initiator,  polymorphic: true
 
     has_many :credit_amounts
     has_many :debit_amounts
@@ -37,7 +38,8 @@ module DoubleDouble
     validate :has_debit_amounts?
     validate :amounts_cancel?
 
-    scope :by_transaction_type_number, ->(tt_num) { where(transaction_type: {number: tt_num})}
+    scope :by_transaction_type, ->(tt) { where(transaction_type: tt)}
+    scope :by_initiator, ->(i) { where(initiator_id: i.id, initiator_type: i.class.base_class) }
 
     # Simple API for building a transaction and associated debit and credit amounts
     #
@@ -45,7 +47,7 @@ module DoubleDouble
     #   transaction = DoubleDouble::Transaction.build(
     #     description: "Sold some widgets",
     #     debits: [
-    #       {account: "Accounts Receivable", amount: 50, context_id: 20, context_type: 'Job'}], 
+    #       {account: "Accounts Receivable", amount: 50, context: @some_active_record_object}], 
     #     credits: [
     #       {account: "Sales Revenue",       amount: 45},
     #       {account: "Sales Tax Payable",   amount:  5}])
@@ -55,7 +57,7 @@ module DoubleDouble
       t = Transaction.new()
       t.description      = args[:description]
       t.transaction_type = args[:transaction_type] if args.has_key? :transaction_type
-
+      t.initiator        = args[:initiator]        if args.has_key? :initiator
       add_amounts_to_transaction(args[:debits],  t, true) 
       add_amounts_to_transaction(args[:credits], t, false)
       t
@@ -66,6 +68,10 @@ module DoubleDouble
       t.save!
     end
 
+    def transaction_type
+      self.transaction_type_id.nil? ? UnassignedTransactionType : TransactionType.find(self.transaction_type_id)
+    end
+
     private
 
       # Validation
@@ -102,10 +108,9 @@ module DoubleDouble
       end
 
       def self.prepare_amount_parameters args
-        prepared_params = { account: Account.find_by_name(args[:account]), transaction: args[:transaction], amount: args[:amount]}
+        prepared_params = { account: Account.named(args[:account]), transaction: args[:transaction], amount: args[:amount]}
         prepared_params.merge!({accountee: args[:accountee]}) if args.has_key? :accountee
         prepared_params.merge!({context:   args[:context]})   if args.has_key? :context
-        prepared_params.merge!({initiator: args[:initiator]}) if args.has_key? :initiator
         prepared_params
       end
   end

data/lib/double_double/transaction_type.rb

@@ -3,9 +3,20 @@ module DoubleDouble
     self.table_name = 'double_double_transaction_types'
     
     has_many :transactions
-    attr_accessible :number, :description
+    attr_accessible :description
 
-    validates_numericality_of :number,      greater_than: 0
-    validates_length_of       :description, minimum: 6
+    validates :description, length: { minimum: 6 }, presence: true, uniqueness: true
+
+    def self.of description_given
+      TransactionType.where(description: description_given.to_s).first
+    end
+  end
+
+  class UnassignedTransactionType
+    class << self
+      def description
+        'unassigned'
+      end
+    end
   end
 end

data/lib/double_double/version.rb

@@ -1,3 +1,3 @@
 module DoubleDouble
-  VERSION = "0.2.0"
+  VERSION = "0.2.3"
 end

data/spec/models/account_spec.rb

@@ -62,7 +62,7 @@ module DoubleDouble
         description: 'spec transaction 05',
         debits:  [{account: 'contra expense acct', amount: 333}], 
         credits: [{account: 'contra revenue acct', amount: 333}])
-      Account.trial_balance.should == 0
+      Account.trial_balance.should eq(0)
     end
   end
 end

data/spec/models/credit_amount_spec.rb

@@ -63,6 +63,7 @@ module DoubleDouble
       @loan.credits_balance({context: @job}).should == Money.new(123 + 321)
       @loan.credits_balance({context: @po}).should == Money.new(275)
       @loan.credits_balance.should == Money.new(123 + 321 + 275 + 999)
+      Account.trial_balance.should eq(0)
     end
   end
 end

data/spec/models/debit_amount_spec.rb

@@ -63,6 +63,7 @@ module DoubleDouble
       @cash.debits_balance({context: @job}).should == Money.new(123 + 321)
       @cash.debits_balance({context: @po}).should == Money.new(275)
       @cash.debits_balance.should == Money.new(123 + 321 + 275 + 999)
+      Account.trial_balance.should eq(0)
     end
   end
 end

data/spec/models/transaction_spec.rb

@@ -4,24 +4,27 @@ module DoubleDouble
     before(:each) do
       @cash = DoubleDouble::Asset.create!(name:'Cash_11', number: 1011)
       @loan = DoubleDouble::Liability.create!(name:'Loan_12', number: 1012)
-
+      # dummy objects to stand-in for accountees
+      @user1 = DoubleDouble::Asset.create!(name:'some user1', number: 8991)
+      @user2 = DoubleDouble::Asset.create!(name:'some user2', number: 8992)
       # dummy objects to stand-in for a context
       @campaign1 = DoubleDouble::Asset.create!(name:'campaign_test1', number: 9991)
       @campaign2 = DoubleDouble::Asset.create!(name:'campaign_test2', number: 9992)
     end
 
-    it 'should create a transaction using the create! method' do
+    it_behaves_like "it can run the README scenarios"
+
+    it 'should create a Transaction using the create! method' do
       -> {
         Transaction.create!(
           description: 'spec transaction 01',
           debits:  [{account: 'Cash_11', amount: 10}],
           credits: [{account: 'Loan_12', amount:  9},
                     {account: 'Loan_12', amount:  1}])
-
       }.should change(DoubleDouble::Transaction, :count).by(1)
     end
 
-    it 'should not create a transaction using the build method' do
+    it 'should not create a Transaction using the build method' do
       -> {
         Transaction.build(
           description: 'spec transaction 01',
@@ -111,8 +114,52 @@ module DoubleDouble
       t.errors['base'].should == ['The credit and debit amounts are not equal']
     end
 
-    describe 'context references' do
-      it 'should allow a transaction to be built describing the context in the hash' do
+    describe 'transaction_types' do
+      it 'should create a Transaction with a TransactionType of Unassigned if none is passed in' do
+        t = Transaction.build(
+          description: 'spec transaction 01',
+          debits:  [{account: 'Cash_11', amount: 10}],
+          credits: [{account: 'Loan_12', amount:  9},
+                    {account: 'Loan_12', amount:  1}])
+        t.transaction_type.description.should eq('unassigned')
+      end
+
+      it 'should create a Transaction with a TransactionType of Unassigned if none is passed in' do
+        TransactionType.create!(description: 'donation')
+        t = Transaction.build(
+          description: 'spec transaction 01',
+          transaction_type: TransactionType.of(:donation),
+          debits:  [{account: 'Cash_11', amount: 10}],
+          credits: [{account: 'Loan_12', amount:  9},
+                    {account: 'Loan_12', amount:  1}])
+        t.transaction_type.description.should eq('donation')
+      end
+    end
+
+    describe 'amount accountee references' do
+      it 'should allow a Transaction to be built describing the accountee in the hash' do
+        Transaction.create!(
+          description: 'Sold some widgets',
+          debits:  [{account: 'Cash_11', amount: 60, context: @campaign1, accountee: @user1},
+                    {account: 'Cash_11', amount: 40, context: @campaign2, accountee: @user1},
+                    {account: 'Cash_11', amount:  4, context: @campaign2, accountee: @user2}], 
+          credits: [{account: 'Loan_12', amount: 45},
+                    {account: 'Loan_12', amount:  9},
+                    {account: 'Loan_12', amount: 50, context: @campaign1}])
+        Amount.by_accountee(@user1).count.should eq(2)
+        Amount.by_accountee(@user2).count.should eq(1)
+
+        @cash.debits_balance(context: @campaign1, accountee: @user1).should eq(60)
+        @cash.debits_balance(context: @campaign1, accountee: @user2).should eq(0)
+        @cash.debits_balance(context: @campaign2, accountee: @user1).should eq(40)
+        @cash.debits_balance(context: @campaign2, accountee: @user2).should eq(4)
+        @cash.debits_balance(context: @campaign2).should eq(44)
+        Account.trial_balance.should eq(0)
+      end  
+    end
+
+    describe 'amount context references' do
+      it 'should allow a Transaction to be built describing the context in the hash' do
         Transaction.create!(
           description: 'Sold some widgets',
           debits:  [{account: 'Cash_11', amount: 60, context: @campaign1},
@@ -122,34 +169,11 @@ module DoubleDouble
                     {account: 'Loan_12', amount: 50, context: @campaign1}])
         Amount.by_context(@campaign1).count.should eq(2)
         Amount.by_context(@campaign2).count.should eq(1)
+
         @cash.debits_balance(context: @campaign1).should eq(60)
         @cash.debits_balance(context: @campaign2).should eq(40)
+        Account.trial_balance.should eq(0)
       end  
     end
-
-    describe 'README.md scenarios' do
-      it 'should perform BASIC SCENARIO A correctly' do
-        DoubleDouble::Asset.create! name:'Cash', number: 11
-        DoubleDouble::Liability.create! name:'Grandpa Loan', number: 12
-        # Grandpa was kind enough to loan us $800 USD in cash for college textbooks.  To enter this we will require a transaction which will affect both 'Cash' and 'Grandpa Loan'
-        DoubleDouble::Transaction.create!(
-          description: 
-            'We received a loan from Grandpa',
-          debits:[
-            {account: 'Cash', amount: '$800'}],
-          credits:[
-            {account: 'Grandpa Loan', amount: '$800'}])
-        # But say that we wanted to return $320 because we were able to purchase a few used books.
-        DoubleDouble::Transaction.create!(
-          description: 
-            'Payed back $320 to Grandpa',
-          debits:[
-            {account: 'Grandpa Loan', amount: '$320'}],
-          credits:[
-            {account: 'Cash', amount: '$320'}])
-        # If we wanted to know how much we still owed Grandpa, we could look at the balance of the account.
-        DoubleDouble::Account.find_by_name('Grandpa Loan').balance.to_s.should eq("480.00")
-      end
-    end
   end
 end

data/spec/models/transaction_type_spec.rb

@@ -0,0 +1,26 @@
+module DoubleDouble
+  describe TransactionType do
+
+    it 'should create a TransactionType using the create! method' do
+      -> {
+        TransactionType.create!(description: '123456')
+      }.should change(DoubleDouble::TransactionType, :count).by(1)
+    end
+
+    it 'should not be valid without a description' do
+      -> {
+        TransactionType.create!(description: '')
+      }.should raise_error(ActiveRecord::RecordInvalid)
+      t = TransactionType.new(description: '')
+      t.should_not be_valid
+    end
+
+    it 'should not be valid without a long-enough description' do
+      -> {
+        TransactionType.create!(description: '12345')
+      }.should raise_error(ActiveRecord::RecordInvalid)
+      t = TransactionType.new(description: '12345')
+      t.should_not be_valid
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -19,23 +19,24 @@ ActiveRecord::Migration.verbose = false
 
     create_table :double_double_transactions do |t|
       t.string :description
+      t.references :initiator,        polymorphic: true
       t.references :transaction_type
       t.timestamps
     end
+    add_index :double_double_transactions, :initiator_id
+    add_index :double_double_transactions, :initiator_type
     add_index :double_double_transactions, :transaction_type_id
 
     create_table :double_double_transaction_types do |t|
-      t.integer :number,        null: false
       t.string :description,    null: false
     end
-    add_index :double_double_transaction_types, :number
+    add_index :double_double_transaction_types, :description
 
     create_table :double_double_amounts do |t|
       t.string :type
       t.references :account
       t.references :transaction
       t.references :context,    polymorphic: true
-      t.references :initiator,  polymorphic: true
       t.references :accountee,  polymorphic: true
       
       t.integer :amount_cents, limit: 8, default: 0, null: false
@@ -43,8 +44,6 @@ ActiveRecord::Migration.verbose = false
     end
     add_index :double_double_amounts, :context_id
     add_index :double_double_amounts, :context_type
-    add_index :double_double_amounts, :initiator_id
-    add_index :double_double_amounts, :initiator_type
     add_index :double_double_amounts, :accountee_id
     add_index :double_double_amounts, :accountee_type
     add_index :double_double_amounts, :type

data/spec/support/normal_credit_account_types.rb

@@ -1,124 +1,128 @@
 # Liability, Equity, and Revenue account types
 shared_examples "a normal credit account type" do
   describe "<<" do
+
+    describe "basic behavior" do
+
+      before(:each) do
+        @acct1         = FactoryGirl.create(normal_credit_account_type, name: 'acct1')
+        @acct2_contra  = FactoryGirl.create(normal_credit_account_type, name: 'acct2_contra', :contra => true)
+        @other_account = FactoryGirl.create("not_#{normal_credit_account_type}".to_sym, name: 'other_account')
+      end
     
-    it "should report a NEGATIVE balance when an account is debited" do
-      account        = FactoryGirl.create(normal_credit_account_type)
-      contra_account = FactoryGirl.create(normal_credit_account_type, :contra => true)
-      t = FactoryGirl.build(:transaction)
-      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: 75, account: account)
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: 75, account: contra_account)
-      t.save
-      account.balance.should        < 0
-      contra_account.balance.should < 0
-    end
+      it "should report a NEGATIVE balance when an account is debited" do
+        DoubleDouble::Transaction.create!(
+          description: 'Sold some widgets',
+          debits:  [{account: 'acct1', amount: Money.new(75)}], 
+          credits: [{account: 'acct2_contra', amount: Money.new(75)}])
+        @acct1.balance.should        < 0
+        @acct2_contra.balance.should < 0
+      end
 
-    it "should report a POSITIVE balance when an account is credited" do
-      account        = FactoryGirl.create(normal_credit_account_type)
-      contra_account = FactoryGirl.create(normal_credit_account_type, :contra => true)
-      t = FactoryGirl.build(:transaction)
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: 75, account: account)
-      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: 75, account: contra_account)
-      t.save
-      account.balance.should        > 0
-      contra_account.balance.should > 0
-    end
+      it "should report a POSITIVE balance when an account is credited" do
+        DoubleDouble::Transaction.create!(
+          description: 'Sold some widgets',
+          debits:  [{account: 'acct2_contra', amount: Money.new(75)}], 
+          credits: [{account: 'acct1', amount: Money.new(75)}])
+        @acct1.balance.should        > 0
+        @acct2_contra.balance.should > 0
+      end
 
-    it "should report a POSITIVE balance across the account type when CREDITED
-     and using an unrelated type for the balanced side transaction" do
-      account       = FactoryGirl.create(normal_credit_account_type)
-      other_account = FactoryGirl.create("not_#{normal_credit_account_type}".to_sym)
-      t = FactoryGirl.build(:transaction)
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: 50, account: account)
-      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: 50, account: other_account)
-      t.save
-      DoubleDouble.const_get(normal_credit_account_type.to_s.capitalize).should respond_to(:balance)
-      DoubleDouble.const_get(normal_credit_account_type.to_s.capitalize).balance.should > 0
-      DoubleDouble.const_get(normal_credit_account_type.to_s.capitalize).balance.should be_kind_of(Money)
-    end
+      it "should report a POSITIVE balance across the account type when CREDITED
+       and using an unrelated type for the balanced side transaction" do
+        DoubleDouble::Transaction.create!(
+          description: 'Sold some widgets',
+          debits:  [{account: 'other_account', amount: Money.new(50)}], 
+          credits: [{account: 'acct1', amount: Money.new(50)}])
+        DoubleDouble.const_get(normal_credit_account_type.to_s.capitalize).should respond_to(:balance)
+        DoubleDouble.const_get(normal_credit_account_type.to_s.capitalize).balance.should > 0
+        DoubleDouble.const_get(normal_credit_account_type.to_s.capitalize).balance.should be_kind_of(Money)
+      end
 
-    it "should report a NEGATIVE balance across the account type when DEBITED
-     and using an unrelated type for the balanced side transaction" do
-      account       = FactoryGirl.create(normal_credit_account_type)
-      other_account = FactoryGirl.create("not_#{normal_credit_account_type}".to_sym)
-      t = FactoryGirl.build(:transaction)
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: 50, account: other_account)
-      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: 50, account: account)
-      t.save
-      DoubleDouble.const_get(normal_credit_account_type.to_s.capitalize).should respond_to(:balance)
-      DoubleDouble.const_get(normal_credit_account_type.to_s.capitalize).balance.should < 0
-      DoubleDouble.const_get(normal_credit_account_type.to_s.capitalize).balance.should be_kind_of(Money)
+      it "should report a NEGATIVE balance across the account type when DEBITED
+       and using an unrelated type for the balanced side transaction" do
+        DoubleDouble::Transaction.create!(
+          description: 'Sold some widgets',
+          debits:  [{account: 'acct1', amount: Money.new(50)}], 
+          credits: [{account: 'other_account', amount: Money.new(50)}])
+        DoubleDouble.const_get(normal_credit_account_type.to_s.capitalize).should respond_to(:balance)
+        DoubleDouble.const_get(normal_credit_account_type.to_s.capitalize).balance.should < 0
+        DoubleDouble.const_get(normal_credit_account_type.to_s.capitalize).balance.should be_kind_of(Money)
+      end
     end
 
-    it "should return the balance with respect to project_id, if project_id is supplied" do
-      acct1         = FactoryGirl.create(normal_credit_account_type, name: 'acct1')
-      acct2         = FactoryGirl.create(normal_credit_account_type, name: 'acct2')
-      other_account = FactoryGirl.create("not_#{normal_credit_account_type}".to_sym, name: 'other_account')
-      a1 = rand(1_000_000_000)
-      a2 = rand(1_000_000_000)
-      a3 = rand(1_000_000_000)
-      a4 = rand(1_000_000_000)
-      @project1 = FactoryGirl.create(normal_credit_account_type)
-      @invoice555 = FactoryGirl.create(normal_credit_account_type)
+    describe "context" do
+
+      it "should return the balance with respect to context is supplied" do
+        acct1         = FactoryGirl.create(normal_credit_account_type, name: 'acct1')
+        acct2         = FactoryGirl.create(normal_credit_account_type, name: 'acct2')
+        other_account = FactoryGirl.create("not_#{normal_credit_account_type}".to_sym, name: 'other_account')
+        a1 = rand(1_000_000_000)
+        a2 = rand(1_000_000_000)
+        a3 = rand(1_000_000_000)
+        a4 = rand(1_000_000_000)
+        @project1 = FactoryGirl.create(normal_credit_account_type)
+        @invoice555 = FactoryGirl.create(normal_credit_account_type)
 
-      DoubleDouble::Transaction.create!(
-        description: 'Sold some widgets',
-        debits:  [{account: 'other_account', amount: Money.new(a1)}], 
-        credits: [{account: 'acct1',         amount: Money.new(a1), context: @project1}])
-      DoubleDouble::Transaction.create!(
-        description: 'Sold something',
-        debits:  [{account: 'other_account', amount: Money.new(a2)}], 
-        credits: [{account: 'acct1',         amount: Money.new(a2), context: @project1}])
-      DoubleDouble::Transaction.create!(
-        description: 'Sold something',
-        debits:  [{account: 'other_account', amount: Money.new(a3)}], 
-        credits: [{account: 'acct1',         amount: Money.new(a3), context: @invoice555}])
-      DoubleDouble::Transaction.create!(
-        description: 'Sold something',
-        debits:  [{account: 'other_account', amount: Money.new(a3)}], 
-        credits: [{account: 'acct1',         amount: Money.new(a3)}])
+        DoubleDouble::Transaction.create!(
+          description: 'Sold some widgets',
+          debits:  [{account: 'other_account', amount: Money.new(a1)}], 
+          credits: [{account: 'acct1',         amount: Money.new(a1), context: @project1}])
+        DoubleDouble::Transaction.create!(
+          description: 'Sold something',
+          debits:  [{account: 'other_account', amount: Money.new(a2)}], 
+          credits: [{account: 'acct1',         amount: Money.new(a2), context: @project1}])
+        DoubleDouble::Transaction.create!(
+          description: 'Sold something',
+          debits:  [{account: 'other_account', amount: Money.new(a3)}], 
+          credits: [{account: 'acct1',         amount: Money.new(a3), context: @invoice555}])
+        DoubleDouble::Transaction.create!(
+          description: 'Sold something',
+          debits:  [{account: 'other_account', amount: Money.new(a3)}], 
+          credits: [{account: 'acct1',         amount: Money.new(a3)}])
 
-      DoubleDouble::Transaction.create!(
-        description: 'Sold something',
-        debits:  [{account: 'acct1',         amount: Money.new(a4), context: @project1}], 
-        credits: [{account: 'other_account', amount: Money.new(a4)}])
-      DoubleDouble::Transaction.create!(
-        description: 'Sold something',
-        debits:  [{account: 'acct1',         amount: Money.new(a2), context: @project1}], 
-        credits: [{account: 'other_account', amount: Money.new(a2)}])
-      DoubleDouble::Transaction.create!(
-        description: 'Sold something',
-        debits:  [{account: 'acct1',         amount: Money.new(a3), context: @invoice555}], 
-        credits: [{account: 'other_account', amount: Money.new(a3)}])
-      DoubleDouble::Transaction.create!(
-        description: 'Sold something',
-        debits:  [{account: 'acct1',         amount: Money.new(a3)}], 
-        credits: [{account: 'other_account', amount: Money.new(a3)}])
+        DoubleDouble::Transaction.create!(
+          description: 'Sold something',
+          debits:  [{account: 'acct1',         amount: Money.new(a4), context: @project1}], 
+          credits: [{account: 'other_account', amount: Money.new(a4)}])
+        DoubleDouble::Transaction.create!(
+          description: 'Sold something',
+          debits:  [{account: 'acct1',         amount: Money.new(a2), context: @project1}], 
+          credits: [{account: 'other_account', amount: Money.new(a2)}])
+        DoubleDouble::Transaction.create!(
+          description: 'Sold something',
+          debits:  [{account: 'acct1',         amount: Money.new(a3), context: @invoice555}], 
+          credits: [{account: 'other_account', amount: Money.new(a3)}])
+        DoubleDouble::Transaction.create!(
+          description: 'Sold something',
+          debits:  [{account: 'acct1',         amount: Money.new(a3)}], 
+          credits: [{account: 'other_account', amount: Money.new(a3)}])
 
-      DoubleDouble::Transaction.create!(
-        description: 'Sold something',
-        debits:  [{account: 'acct2',         amount: Money.new(a4), context: @project1}], 
-        credits: [{account: 'other_account', amount: Money.new(a4)}])
-      DoubleDouble::Transaction.create!(
-        description: 'Sold something',
-        debits:  [{account: 'acct2',         amount: Money.new(a2), context: @project1}], 
-        credits: [{account: 'other_account', amount: Money.new(a2)}])
-      DoubleDouble::Transaction.create!(
-        description: 'Sold something',
-        debits:  [{account: 'acct2',         amount: Money.new(a3), context: @invoice555}], 
-        credits: [{account: 'other_account', amount: Money.new(a3)}])
-      DoubleDouble::Transaction.create!(
-        description: 'Sold something',
-        debits:  [{account: 'acct2',         amount: Money.new(a3)}], 
-        credits: [{account: 'other_account', amount: Money.new(a3)}])
+        DoubleDouble::Transaction.create!(
+          description: 'Sold something',
+          debits:  [{account: 'acct2',         amount: Money.new(a4), context: @project1}], 
+          credits: [{account: 'other_account', amount: Money.new(a4)}])
+        DoubleDouble::Transaction.create!(
+          description: 'Sold something',
+          debits:  [{account: 'acct2',         amount: Money.new(a2), context: @project1}], 
+          credits: [{account: 'other_account', amount: Money.new(a2)}])
+        DoubleDouble::Transaction.create!(
+          description: 'Sold something',
+          debits:  [{account: 'acct2',         amount: Money.new(a3), context: @invoice555}], 
+          credits: [{account: 'other_account', amount: Money.new(a3)}])
+        DoubleDouble::Transaction.create!(
+          description: 'Sold something',
+          debits:  [{account: 'acct2',         amount: Money.new(a3)}], 
+          credits: [{account: 'other_account', amount: Money.new(a3)}])
 
-      acct1.balance({context: @project1}).should   == Money.new((a1 + a2) - (a4 + a2))
-      acct1.balance({context: @invoice555}).should == Money.new(a3 - a3)
-      acct1.balance.should                         == Money.new((a1 + a2 + a3 + a3) - (a4 + a2 + a3 + a3))
-      
-      acct2.balance({context: @project1}).should   == Money.new(- (a4 + a2))
-      acct2.balance({context: @invoice555}).should == Money.new(- a3)
-      acct2.balance.should                         == Money.new(- (a4 + a2 + a3 + a3))
+        acct1.balance({context: @project1}).should   == Money.new((a1 + a2) - (a4 + a2))
+        acct1.balance({context: @invoice555}).should == Money.new(a3 - a3)
+        acct1.balance.should                         == Money.new((a1 + a2 + a3 + a3) - (a4 + a2 + a3 + a3))
+        
+        acct2.balance({context: @project1}).should   == Money.new(- (a4 + a2))
+        acct2.balance({context: @invoice555}).should == Money.new(- a3)
+        acct2.balance.should                         == Money.new(- (a4 + a2 + a3 + a3))
+      end
     end
   end
 end

data/spec/support/normal_debit_account_types.rb

@@ -1,124 +1,128 @@
 # Asset and Expense account types
 shared_examples "a normal debit account type" do
   describe "<<" do
+
+    describe "basic behavior" do
+
+      before(:each) do
+        @acct1         = FactoryGirl.create(normal_debit_account_type, name: 'acct1')
+        @acct2_contra  = FactoryGirl.create(normal_debit_account_type, name: 'acct2_contra', :contra => true)
+        @other_account = FactoryGirl.create("not_#{normal_debit_account_type}".to_sym, name: 'other_account')
+      end
     
-    it "should report a POSITIVE balance when an account is DEBITED" do
-      account        = FactoryGirl.create(normal_debit_account_type)
-      contra_account = FactoryGirl.create(normal_debit_account_type, :contra => true)
-      t = FactoryGirl.build(:transaction)
-      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: 75, account: account)
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: 75, account: contra_account)
-      t.save
-      account.balance.should        > 0
-      contra_account.balance.should > 0
-    end
+      it "should report a POSITIVE balance when an account is DEBITED" do
+        DoubleDouble::Transaction.create!(
+          description: 'Sold some widgets',
+          debits:  [{account: 'acct1', amount: Money.new(75)}], 
+          credits: [{account: 'acct2_contra', amount: Money.new(75)}])
+        @acct1.balance.should        > 0
+        @acct2_contra.balance.should > 0
+      end
 
-    it "should report a NEGATIVE balance when an account is CREDITED" do
-      account        = FactoryGirl.create(normal_debit_account_type)
-      contra_account = FactoryGirl.create(normal_debit_account_type, :contra => true)
-      t = FactoryGirl.build(:transaction)
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: 75, account: account)
-      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: 75, account: contra_account)
-      t.save
-      account.balance.should        < 0
-      contra_account.balance.should < 0
-    end
+      it "should report a NEGATIVE balance when an account is CREDITED" do
+        DoubleDouble::Transaction.create!(
+          description: 'Sold some widgets',
+          debits:  [{account: 'acct2_contra', amount: Money.new(75)}], 
+          credits: [{account: 'acct1', amount: Money.new(75)}])
+        @acct1.balance.should        < 0
+        @acct2_contra.balance.should < 0
+      end
 
-    it "should report a NEGATIVE balance across the account type when CREDITED
-     and using an unrelated type for the balanced side transaction" do
-      account       = FactoryGirl.create(normal_debit_account_type)
-      other_account = FactoryGirl.create("not_#{normal_debit_account_type}".to_sym)
-      t = FactoryGirl.build(:transaction)
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: 50, account: account)
-      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: 50, account: other_account)
-      t.save
-      DoubleDouble.const_get(normal_debit_account_type.to_s.capitalize).should respond_to(:balance)
-      DoubleDouble.const_get(normal_debit_account_type.to_s.capitalize).balance.should < 0
-      DoubleDouble.const_get(normal_debit_account_type.to_s.capitalize).balance.should be_kind_of(Money)
-    end
+      it "should report a NEGATIVE balance across the account type when CREDITED
+       and using an unrelated type for the balanced side transaction" do
+        DoubleDouble::Transaction.create!(
+          description: 'Sold some widgets',
+          debits:  [{account: 'other_account', amount: Money.new(50)}], 
+          credits: [{account: 'acct1', amount: Money.new(50)}])
+        DoubleDouble.const_get(normal_debit_account_type.to_s.capitalize).should respond_to(:balance)
+        DoubleDouble.const_get(normal_debit_account_type.to_s.capitalize).balance.should < 0
+        DoubleDouble.const_get(normal_debit_account_type.to_s.capitalize).balance.should be_kind_of(Money)
+      end
 
-    it "should report a POSITIVE balance across the account type when DEBITED
-     and using an unrelated type for the balanced side transaction" do
-      account       = FactoryGirl.create(normal_debit_account_type)
-      other_account = FactoryGirl.create("not_#{normal_debit_account_type}".to_sym)
-      t = FactoryGirl.build(:transaction)
-      t.credit_amounts << FactoryGirl.create(:credit_amt, transaction: t, amount: 50, account: other_account)
-      t.debit_amounts  << FactoryGirl.create(:debit_amt,  transaction: t, amount: 50, account: account)
-      t.save
-      DoubleDouble.const_get(normal_debit_account_type.to_s.capitalize).should respond_to(:balance)
-      DoubleDouble.const_get(normal_debit_account_type.to_s.capitalize).balance.should > 0
-      DoubleDouble.const_get(normal_debit_account_type.to_s.capitalize).balance.should be_kind_of(Money)
+      it "should report a POSITIVE balance across the account type when DEBITED
+       and using an unrelated type for the balanced side transaction" do
+        DoubleDouble::Transaction.create!(
+          description: 'Sold some widgets',
+          debits:  [{account: 'acct1', amount: Money.new(50)}], 
+          credits: [{account: 'other_account', amount: Money.new(50)}])
+        DoubleDouble.const_get(normal_debit_account_type.to_s.capitalize).should respond_to(:balance)
+        DoubleDouble.const_get(normal_debit_account_type.to_s.capitalize).balance.should > 0
+        DoubleDouble.const_get(normal_debit_account_type.to_s.capitalize).balance.should be_kind_of(Money)
+      end
     end
 
-    it "should return the balance with respect to project_id, if project_id is supplied" do
-      acct1         = FactoryGirl.create(normal_debit_account_type, name: 'acct1')
-      acct2         = FactoryGirl.create(normal_debit_account_type, name: 'acct2')
-      other_account = FactoryGirl.create("not_#{normal_debit_account_type}".to_sym, name: 'other_account')
-      a1 = rand(1_000_000_000)
-      a2 = rand(1_000_000_000)
-      a3 = rand(1_000_000_000)
-      a4 = rand(1_000_000_000)
-      @project1 = FactoryGirl.create(normal_debit_account_type)
-      @invoice555 = FactoryGirl.create(normal_debit_account_type)
+    describe "context" do
+
+      it "should return the balance with respect to context is supplied" do
+        acct1         = FactoryGirl.create(normal_debit_account_type, name: 'acct1')
+        acct2         = FactoryGirl.create(normal_debit_account_type, name: 'acct2')
+        other_account = FactoryGirl.create("not_#{normal_debit_account_type}".to_sym, name: 'other_account')
+        a1 = rand(1_000_000_000)
+        a2 = rand(1_000_000_000)
+        a3 = rand(1_000_000_000)
+        a4 = rand(1_000_000_000)
+        @project1 = FactoryGirl.create(normal_debit_account_type)
+        @invoice555 = FactoryGirl.create(normal_debit_account_type)
 
-      DoubleDouble::Transaction.create!(
-        description: 'Sold some widgets',
-        debits:  [{account: 'other_account', amount: Money.new(a1)}], 
-        credits: [{account: 'acct1',         amount: Money.new(a1), context: @project1}])
-      DoubleDouble::Transaction.create!(
-        description: 'Sold something',
-        debits:  [{account: 'other_account', amount: Money.new(a2)}], 
-        credits: [{account: 'acct1',         amount: Money.new(a2), context: @project1}])
-      DoubleDouble::Transaction.create!(
-        description: 'Sold something',
-        debits:  [{account: 'other_account', amount: Money.new(a3)}], 
-        credits: [{account: 'acct1',         amount: Money.new(a3), context: @invoice555}])
-      DoubleDouble::Transaction.create!(
-        description: 'Sold something',
-        debits:  [{account: 'other_account', amount: Money.new(a3)}], 
-        credits: [{account: 'acct1',         amount: Money.new(a3)}])
+        DoubleDouble::Transaction.create!(
+          description: 'Sold some widgets',
+          debits:  [{account: 'other_account', amount: Money.new(a1)}], 
+          credits: [{account: 'acct1',         amount: Money.new(a1), context: @project1}])
+        DoubleDouble::Transaction.create!(
+          description: 'Sold something',
+          debits:  [{account: 'other_account', amount: Money.new(a2)}], 
+          credits: [{account: 'acct1',         amount: Money.new(a2), context: @project1}])
+        DoubleDouble::Transaction.create!(
+          description: 'Sold something',
+          debits:  [{account: 'other_account', amount: Money.new(a3)}], 
+          credits: [{account: 'acct1',         amount: Money.new(a3), context: @invoice555}])
+        DoubleDouble::Transaction.create!(
+          description: 'Sold something',
+          debits:  [{account: 'other_account', amount: Money.new(a3)}], 
+          credits: [{account: 'acct1',         amount: Money.new(a3)}])
 
-      DoubleDouble::Transaction.create!(
-        description: 'Sold something',
-        debits:  [{account: 'acct1',         amount: Money.new(a4), context: @project1}], 
-        credits: [{account: 'other_account', amount: Money.new(a4)}])
-      DoubleDouble::Transaction.create!(
-        description: 'Sold something',
-        debits:  [{account: 'acct1',         amount: Money.new(a2), context: @project1}], 
-        credits: [{account: 'other_account', amount: Money.new(a2)}])
-      DoubleDouble::Transaction.create!(
-        description: 'Sold something',
-        debits:  [{account: 'acct1',         amount: Money.new(a3), context: @invoice555}], 
-        credits: [{account: 'other_account', amount: Money.new(a3)}])
-      DoubleDouble::Transaction.create!(
-        description: 'Sold something',
-        debits:  [{account: 'acct1',         amount: Money.new(a3)}], 
-        credits: [{account: 'other_account', amount: Money.new(a3)}])
+        DoubleDouble::Transaction.create!(
+          description: 'Sold something',
+          debits:  [{account: 'acct1',         amount: Money.new(a4), context: @project1}], 
+          credits: [{account: 'other_account', amount: Money.new(a4)}])
+        DoubleDouble::Transaction.create!(
+          description: 'Sold something',
+          debits:  [{account: 'acct1',         amount: Money.new(a2), context: @project1}], 
+          credits: [{account: 'other_account', amount: Money.new(a2)}])
+        DoubleDouble::Transaction.create!(
+          description: 'Sold something',
+          debits:  [{account: 'acct1',         amount: Money.new(a3), context: @invoice555}], 
+          credits: [{account: 'other_account', amount: Money.new(a3)}])
+        DoubleDouble::Transaction.create!(
+          description: 'Sold something',
+          debits:  [{account: 'acct1',         amount: Money.new(a3)}], 
+          credits: [{account: 'other_account', amount: Money.new(a3)}])
 
-      DoubleDouble::Transaction.create!(
-        description: 'Sold something',
-        debits:  [{account: 'acct2',         amount: Money.new(a4), context: @project1}], 
-        credits: [{account: 'other_account', amount: Money.new(a4)}])
-      DoubleDouble::Transaction.create!(
-        description: 'Sold something',
-        debits:  [{account: 'acct2',         amount: Money.new(a2), context: @project1}], 
-        credits: [{account: 'other_account', amount: Money.new(a2)}])
-      DoubleDouble::Transaction.create!(
-        description: 'Sold something',
-        debits:  [{account: 'acct2',         amount: Money.new(a3), context: @invoice555}], 
-        credits: [{account: 'other_account', amount: Money.new(a3)}])
-      DoubleDouble::Transaction.create!(
-        description: 'Sold something',
-        debits:  [{account: 'acct2',         amount: Money.new(a3)}], 
-        credits: [{account: 'other_account', amount: Money.new(a3)}])
+        DoubleDouble::Transaction.create!(
+          description: 'Sold something',
+          debits:  [{account: 'acct2',         amount: Money.new(a4), context: @project1}], 
+          credits: [{account: 'other_account', amount: Money.new(a4)}])
+        DoubleDouble::Transaction.create!(
+          description: 'Sold something',
+          debits:  [{account: 'acct2',         amount: Money.new(a2), context: @project1}], 
+          credits: [{account: 'other_account', amount: Money.new(a2)}])
+        DoubleDouble::Transaction.create!(
+          description: 'Sold something',
+          debits:  [{account: 'acct2',         amount: Money.new(a3), context: @invoice555}], 
+          credits: [{account: 'other_account', amount: Money.new(a3)}])
+        DoubleDouble::Transaction.create!(
+          description: 'Sold something',
+          debits:  [{account: 'acct2',         amount: Money.new(a3)}], 
+          credits: [{account: 'other_account', amount: Money.new(a3)}])
 
-      acct1.balance({context: @project1}).should   == Money.new((a4 + a2) - (a1 + a2))
-      acct1.balance({context: @invoice555}).should == Money.new(a3 - a3)
-      acct1.balance.should                         == Money.new((a4 + a2 + a3 + a3) - (a1 + a2 + a3 + a3))
-      
-      acct2.balance({context: @project1}).should   == Money.new((a4 + a2))
-      acct2.balance({context: @invoice555}).should == Money.new(a3)
-      acct2.balance.should                         == Money.new((a4 + a2 + a3 + a3))
+        acct1.balance({context: @project1}).should   == Money.new((a4 + a2) - (a1 + a2))
+        acct1.balance({context: @invoice555}).should == Money.new(a3 - a3)
+        acct1.balance.should                         == Money.new((a4 + a2 + a3 + a3) - (a1 + a2 + a3 + a3))
+        
+        acct2.balance({context: @project1}).should   == Money.new((a4 + a2))
+        acct2.balance({context: @invoice555}).should == Money.new(a3)
+        acct2.balance.should                         == Money.new((a4 + a2 + a3 + a3))
+      end
     end
   end
 end

data/spec/support/readme_scenarios.rb

@@ -0,0 +1,50 @@
+shared_examples "it can run the README scenarios" do
+  describe "<<" do
+
+    it 'should perform BASIC SCENARIO A correctly' do
+      DoubleDouble::Asset.create! name:'Cash', number: 11
+      DoubleDouble::Liability.create! name:'Grandpa Loan', number: 12
+      DoubleDouble::Expense.create! name:'Spending', number: 13
+      # Grandpa was kind enough to loan us $800 USD in cash for college textbooks.  To enter this we will require a transaction which will affect both 'Cash' and 'Grandpa Loan'
+      DoubleDouble::Transaction.create!(
+        description: 
+          'We received a loan from Grandpa',
+        debits:[
+          {account: 'Cash', amount: '$800'}],
+        credits:[
+          {account: 'Grandpa Loan', amount: '$800'}])
+      # We buy our college textbooks.  Luckily we had more than enough.
+      DoubleDouble::Transaction.create!(
+        description: 
+          'Purchase textbooks from bookstore',
+        debits:[
+          {account: 'Spending', amount: '$480'}],
+        credits:[
+          {account: 'Cash', amount: '$480'}])
+      # How much cash is left?
+      DoubleDouble::Account.named('Cash').balance.to_s.should eq("320.00")
+      # We deceided that we wanted to return $320 of the loan.
+      DoubleDouble::Transaction.create!(
+        description: 
+          'Payed back $320 to Grandpa',
+        debits:[
+          {account: 'Grandpa Loan', amount: '$320'}],
+        credits:[
+          {account: 'Cash', amount: '$320'}])
+      # How much do we still owed Grandpa?
+      DoubleDouble::Account.named('Grandpa Loan').balance.to_s.should eq("480.00")
+      # How much did we spend?
+      DoubleDouble::Account.named('Spending').balance.to_s.should eq("480.00")
+      # How much cash do we have left?
+      DoubleDouble::Account.named('Cash').balance.to_s.should eq("0.00")
+    end
+
+    it 'should perform the REALISTIC SCENARIO correctly' do
+      pending "TODO"
+    end
+
+    it 'should perform the COMPLEX SCENARIO correctly' do
+      pending "TODO"
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: double_double
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-30 00:00:00.000000000 Z
+date: 2013-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: money
@@ -156,7 +156,6 @@ files:
 - spec/factories/account_factory.rb
 - spec/factories/amount_factory.rb
 - spec/factories/transaction_factory.rb
-- spec/factories/transaction_type_factory.rb
 - spec/models/account_spec.rb
 - spec/models/amount_spec.rb
 - spec/models/asset_spec.rb
@@ -167,10 +166,12 @@ files:
 - spec/models/liability_spec.rb
 - spec/models/revenue_spec.rb
 - spec/models/transaction_spec.rb
+- spec/models/transaction_type_spec.rb
 - spec/spec_helper.rb
 - spec/support/all_account_types.rb
 - spec/support/normal_credit_account_types.rb
 - spec/support/normal_debit_account_types.rb
+- spec/support/readme_scenarios.rb
 homepage: https://github.com/crftr/double_double
 licenses: []
 post_install_message: 
@@ -182,7 +183,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -200,7 +201,6 @@ test_files:
 - spec/factories/account_factory.rb
 - spec/factories/amount_factory.rb
 - spec/factories/transaction_factory.rb
-- spec/factories/transaction_type_factory.rb
 - spec/models/account_spec.rb
 - spec/models/amount_spec.rb
 - spec/models/asset_spec.rb
@@ -211,8 +211,10 @@ test_files:
 - spec/models/liability_spec.rb
 - spec/models/revenue_spec.rb
 - spec/models/transaction_spec.rb
+- spec/models/transaction_type_spec.rb
 - spec/spec_helper.rb
 - spec/support/all_account_types.rb
 - spec/support/normal_credit_account_types.rb
 - spec/support/normal_debit_account_types.rb
+- spec/support/readme_scenarios.rb
 has_rdoc: 

data/spec/factories/transaction_type_factory.rb

@@ -1,14 +0,0 @@
-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