double_entry 0.10.0 → 0.10.1

data/lib/double_entry/validation/line_check.rb

@@ -2,119 +2,125 @@
 require 'set'
 
 module DoubleEntry
- module Validation
-  class LineCheck < ActiveRecord::Base
+  module Validation
+    class LineCheck < ActiveRecord::Base
+      default_scope -> { order('created_at') }
 
-    default_scope -> { order('created_at') }
+      def self.perform!
+        new.perform
+      end
 
-    def self.perform!
-      new.perform
-    end
+      def perform
+        log = ''
+        current_line_id = nil
 
-    def perform
-      log = ''
-      current_line_id = nil
+        active_accounts    = Set.new
+        incorrect_accounts = Set.new
 
-      active_accounts    = Set.new
-      incorrect_accounts = Set.new
+        new_lines_since_last_run.find_each do |line|
+          incorrect_accounts << line.account unless running_balance_correct?(line, log)
+          active_accounts << line.account
+          current_line_id = line.id
+        end
 
-      new_lines_since_last_run.find_each do |line|
-        incorrect_accounts << line.account unless running_balance_correct?(line, log)
-        active_accounts    << line.account
-        current_line_id = line.id
-      end
+        active_accounts.each do |account|
+          incorrect_accounts << account      unless cached_balance_correct?(account)
+        end
+
+        incorrect_accounts.each { |account| recalculate_account(account) }
 
-      active_accounts.each do |account|
-        incorrect_accounts << account      unless cached_balance_correct?(account)
+        unless active_accounts.empty?
+          LineCheck.create!(
+            :errors_found => incorrect_accounts.any?,
+            :last_line_id => current_line_id,
+            :log          => log,
+          )
+        end
       end
 
-      incorrect_accounts.each { |account| recalculate_account(account) }
+    private
 
-      unless active_accounts.empty?
-        LineCheck.create!(
-          :errors_found => incorrect_accounts.any?,
-          :last_line_id => current_line_id,
-          :log          => log,
-        )
+      def last_run_line_id
+        latest = LineCheck.last
+        latest ? latest.last_line_id : 0
       end
-    end
-
-  private
 
-    def last_run_line_id
-      latest = LineCheck.last
-      latest ? latest.last_line_id : 0
-    end
+      def new_lines_since_last_run
+        Line.where('id > ?', last_run_line_id)
+      end
 
-    def new_lines_since_last_run
-      Line.where('id > ?', last_run_line_id)
-    end
+      def running_balance_correct?(line, log)
+        # Another work around for the MySQL 5.1 query optimiser bug that causes the ORDER BY
+        # on the query to fail in some circumstances, resulting in an old balance being
+        # returned. This was biting us intermittently in spec runs.
+        # See http://bugs.mysql.com/bug.php?id=51431
+        force_index = if Line.connection.adapter_name.match(/mysql/i)
+                        'FORCE INDEX (lines_scope_account_id_idx)'
+                      else
+                        ''
+                      end
+
+        # yes, it needs to be find_by_sql, because any other find will be affected
+        # by the find_each call in perform!
+        previous_line = Line.find_by_sql([<<-SQL, line.account.identifier.to_s, line.scope, line.id])
+          SELECT * FROM #{Line.quoted_table_name} #{force_index}
+          WHERE account = ?
+          AND scope = ?
+          AND id < ?
+          ORDER BY id DESC
+          LIMIT 1
+        SQL
+
+        previous_balance = previous_line.length == 1 ? previous_line[0].balance : Money.zero(line.account.currency)
+
+        if line.balance != (line.amount + previous_balance)
+          log << line_error_message(line, previous_line, previous_balance)
+        end
 
-    def running_balance_correct?(line, log)
-      # Another work around for the MySQL 5.1 query optimiser bug that causes the ORDER BY
-      # on the query to fail in some circumstances, resulting in an old balance being
-      # returned. This was biting us intermittently in spec runs.
-      # See http://bugs.mysql.com/bug.php?id=51431
-      force_index = if Line.connection.adapter_name.match /mysql/i
-                      "FORCE INDEX (lines_scope_account_id_idx)"
-                    else
-                      ""
-                    end
-
-      # yes, it needs to be find_by_sql, because any other find will be affected
-      # by the find_each call in perform!
-      previous_line = Line.find_by_sql(["SELECT * FROM #{Line.quoted_table_name} #{force_index} WHERE account = ? AND scope = ? AND id < ? ORDER BY id DESC LIMIT 1", line.account.identifier.to_s, line.scope, line.id])
-
-      previous_balance = previous_line.length == 1 ? previous_line[0].balance : Money.zero(line.account.currency)
-
-      if line.balance != (line.amount + previous_balance)
-        log << line_error_message(line, previous_line, previous_balance)
+        line.balance == previous_balance + line.amount
       end
 
-      line.balance == previous_balance + line.amount
-    end
-
-    def line_error_message(line, previous_line, previous_balance)
-      <<-END_OF_MESSAGE.strip_heredoc
+      def line_error_message(line, previous_line, previous_balance)
+        <<-END_OF_MESSAGE.strip_heredoc
         *********************************
         Error on line ##{line.id}: balance:#{line.balance} != #{previous_balance} + #{line.amount}
         *********************************
-        #{previous_line.inspect}
-        #{line.inspect}
+          #{previous_line.inspect}
+          #{line.inspect}
 
-      END_OF_MESSAGE
-    end
+          END_OF_MESSAGE
+      end
 
-    def cached_balance_correct?(account)
-      DoubleEntry.lock_accounts(account) do
-        return AccountBalance.find_by_account(account).balance == account.balance
+      def cached_balance_correct?(account)
+        DoubleEntry.lock_accounts(account) do
+          return AccountBalance.find_by_account(account).balance == account.balance
+        end
       end
-    end
 
-    def recalculate_account(account)
-      DoubleEntry.lock_accounts(account) do
-        recalculated_balance = Money.zero(account.currency)
+      def recalculate_account(account)
+        DoubleEntry.lock_accounts(account) do
+          recalculated_balance = Money.zero(account.currency)
 
-        lines_for_account(account).each do |line|
-          recalculated_balance += line.amount
-          line.update_attribute(:balance, recalculated_balance) if line.balance != recalculated_balance
-        end
+          lines_for_account(account).each do |line|
+            recalculated_balance += line.amount
+            line.update_attribute(:balance, recalculated_balance) if line.balance != recalculated_balance
+          end
 
-        update_balance_for_account(account, recalculated_balance)
+          update_balance_for_account(account, recalculated_balance)
+        end
       end
-    end
 
-    def lines_for_account(account)
-      Line.where(
-        :account => account.identifier.to_s,
-        :scope   => account.scope_identity.to_s
-      ).order(:id)
-    end
+      def lines_for_account(account)
+        Line.where(
+          :account => account.identifier.to_s,
+          :scope   => account.scope_identity.to_s,
+        ).order(:id)
+      end
 
-    def update_balance_for_account(account, balance)
-      account_balance = Locking.balance_for_locked_account(account)
-      account_balance.update_attribute(:balance, balance)
+      def update_balance_for_account(account, balance)
+        account_balance = Locking.balance_for_locked_account(account)
+        account_balance.update_attribute(:balance, balance)
+      end
     end
   end
- end
 end

data/lib/double_entry/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module DoubleEntry
-  VERSION = "0.10.0"
+  VERSION = '0.10.1'
 end

data/lib/generators/double_entry/install/install_generator.rb

@@ -14,9 +14,8 @@ module DoubleEntry
       end
 
       def copy_migrations
-        migration_template "migration.rb", "db/migrate/create_double_entry_tables.rb"
+        migration_template 'migration.rb', 'db/migrate/create_double_entry_tables.rb'
       end
-
     end
   end
 end

data/lib/generators/double_entry/install/templates/migration.rb

@@ -54,7 +54,6 @@ class CreateDoubleEntryTables < ActiveRecord::Migration
       t.text       "log"
       t.timestamps                             :null => false
     end
-
   end
 
   def self.down
@@ -63,5 +62,4 @@ class CreateDoubleEntryTables < ActiveRecord::Migration
     drop_table "double_entry_lines"
     drop_table "double_entry_account_balances"
   end
-
 end

data/script/jack_hammer

@@ -68,7 +68,7 @@ end
 def clean_out_database
   puts "Cleaning out the database..."
 
-  DatabaseCleaner.clean_with(:deletion)
+  DatabaseCleaner.clean_with(:truncation)
 end
 
 def create_accounts_and_transfers

data/spec/active_record/locking_extensions_spec.rb

@@ -1,12 +1,11 @@
 # encoding: utf-8
-require 'spec_helper'
 
-describe ActiveRecord::LockingExtensions do
-  PG_DEADLOCK    = ActiveRecord::StatementInvalid.new("PG::Error: ERROR:  deadlock detected")
-  MYSQL_DEADLOCK = ActiveRecord::StatementInvalid.new("Mysql::Error: Deadlock found when trying to get lock")
-  SQLITE3_LOCK   = ActiveRecord::StatementInvalid.new("SQLite3::BusyException: database is locked: UPDATE...")
+RSpec.describe ActiveRecord::LockingExtensions do
+  PG_DEADLOCK    = ActiveRecord::StatementInvalid.new('PG::Error: ERROR:  deadlock detected')
+  MYSQL_DEADLOCK = ActiveRecord::StatementInvalid.new('Mysql::Error: Deadlock found when trying to get lock')
+  SQLITE3_LOCK   = ActiveRecord::StatementInvalid.new('SQLite3::BusyException: database is locked: UPDATE...')
 
-  context "#restartable_transaction" do
+  context '#restartable_transaction' do
     it "keeps running the lock until a ActiveRecord::RestartTransaction isn't raised" do
       expect(User).to receive(:create!).ordered.and_raise(ActiveRecord::RestartTransaction)
       expect(User).to receive(:create!).ordered.and_raise(ActiveRecord::RestartTransaction)
@@ -16,88 +15,96 @@ describe ActiveRecord::LockingExtensions do
     end
   end
 
-  context "#with_restart_on_deadlock" do
-    shared_examples "abstract adapter" do
-      it "raises a ActiveRecord::RestartTransaction error if a deadlock occurs" do
-        expect { User.with_restart_on_deadlock { raise exception } }.to raise_error(ActiveRecord::RestartTransaction)
+  context '#with_restart_on_deadlock' do
+    shared_examples 'abstract adapter' do
+      it 'raises a ActiveRecord::RestartTransaction error if a deadlock occurs' do
+        expect { User.with_restart_on_deadlock { fail exception } }.
+          to raise_error(ActiveRecord::RestartTransaction)
       end
 
-      it "publishes a notification" do
-        expect(ActiveSupport::Notifications).to receive(:publish).with("deadlock_restart.active_record", hash_including(:exception => exception))
-        expect { User.with_restart_on_deadlock { raise exception } }.to raise_error
+      it 'publishes a notification' do
+        expect(ActiveSupport::Notifications).
+          to receive(:publish).
+          with('deadlock_restart.active_record', hash_including(:exception => exception))
+        expect { User.with_restart_on_deadlock { fail exception } }.to raise_error
       end
     end
 
-    context "mysql" do
+    context 'mysql' do
       let(:exception) { MYSQL_DEADLOCK }
 
-      it_behaves_like "abstract adapter"
+      it_behaves_like 'abstract adapter'
     end
 
-    context "postgres" do
+    context 'postgres' do
       let(:exception) { PG_DEADLOCK }
 
-      it_behaves_like "abstract adapter"
+      it_behaves_like 'abstract adapter'
     end
 
-    context "sqlite" do
+    context 'sqlite' do
       let(:exception) { SQLITE3_LOCK }
 
-      it_behaves_like "abstract adapter"
+      it_behaves_like 'abstract adapter'
     end
   end
 
-  context "#create_ignoring_duplicates" do
-    it "does not raise an error if a duplicate index error is raised in the database" do
-      User.make! :username => "keith"
+  context '#create_ignoring_duplicates' do
+    it 'does not raise an error if a duplicate index error is raised in the database' do
+      User.make! :username => 'keith'
 
-      expect { User.make! :username => "keith" }.to raise_error
-      expect { User.create_ignoring_duplicates! :username => "keith" }.to_not raise_error
+      expect { User.make! :username => 'keith' }.to raise_error
+      expect { User.create_ignoring_duplicates! :username => 'keith' }.to_not raise_error
     end
 
-    it "publishes a notification when a duplicate is encountered" do
-      User.make! :username => "keith"
+    it 'publishes a notification when a duplicate is encountered' do
+      User.make! :username => 'keith'
 
-      expect(ActiveSupport::Notifications).to receive(:publish).with("duplicate_ignore.active_record", hash_including(:exception => kind_of(ActiveRecord::RecordNotUnique)))
+      expect(ActiveSupport::Notifications).
+        to receive(:publish).
+        with('duplicate_ignore.active_record', hash_including(:exception => kind_of(ActiveRecord::RecordNotUnique)))
 
-      expect { User.create_ignoring_duplicates! :username => "keith" }.to_not raise_error
+      expect { User.create_ignoring_duplicates! :username => 'keith' }.to_not raise_error
     end
 
-    shared_examples "abstract adapter" do
-      it "retries the creation if a deadlock error is raised from the database" do
+    shared_examples 'abstract adapter' do
+      it 'retries the creation if a deadlock error is raised from the database' do
         expect(User).to receive(:create!).ordered.and_raise(exception)
         expect(User).to receive(:create!).ordered.and_return(true)
 
         expect { User.create_ignoring_duplicates! }.to_not raise_error
       end
 
-      it "publishes a notification on each retry" do
+      it 'publishes a notification on each retry' do
         expect(User).to receive(:create!).ordered.and_raise(exception)
         expect(User).to receive(:create!).ordered.and_raise(exception)
         expect(User).to receive(:create!).ordered.and_return(true)
 
-        expect(ActiveSupport::Notifications).to receive(:publish).with("deadlock_retry.active_record", hash_including(:exception => exception)).twice
+        expect(ActiveSupport::Notifications).
+          to receive(:publish).
+          with('deadlock_retry.active_record', hash_including(:exception => exception)).
+          twice
 
         expect { User.create_ignoring_duplicates! }.to_not raise_error
       end
     end
 
-    context "mysql" do
+    context 'mysql' do
       let(:exception) { MYSQL_DEADLOCK }
 
-      it_behaves_like "abstract adapter"
+      it_behaves_like 'abstract adapter'
     end
 
-    context "postgres" do
+    context 'postgres' do
       let(:exception) { PG_DEADLOCK }
 
-      it_behaves_like "abstract adapter"
+      it_behaves_like 'abstract adapter'
     end
 
-    context "sqlite" do
+    context 'sqlite' do
       let(:exception) { SQLITE3_LOCK }
 
-      it_behaves_like "abstract adapter"
+      it_behaves_like 'abstract adapter'
     end
   end
 end

data/spec/double_entry/account_balance_spec.rb

@@ -1,8 +1,7 @@
 # encoding: utf-8
-require 'spec_helper'
-describe DoubleEntry::AccountBalance do
-
-  it "has a table name prefixed with double_entry_" do
-    expect(DoubleEntry::AccountBalance.table_name).to eq "double_entry_account_balances"
+RSpec.describe DoubleEntry::AccountBalance do
+  describe '.table_name' do
+    subject { DoubleEntry::AccountBalance.table_name }
+    it { should eq('double_entry_account_balances') }
   end
 end

data/spec/double_entry/account_spec.rb

@@ -1,19 +1,18 @@
 # encoding: utf-8
-require 'spec_helper'
 module DoubleEntry
-  describe Account do
+  RSpec.describe Account do
     let(:identity_scope) { ->(value) { value } }
 
-    describe "::new" do
-      context "given an identifier 31 characters in length" do
-        let(:identifier) { "xxxxxxxx 31 characters xxxxxxxx" }
+    describe '::new' do
+      context 'given an identifier 31 characters in length' do
+        let(:identifier) { 'xxxxxxxx 31 characters xxxxxxxx' }
         specify do
           expect { Account.new(:identifier => identifier) }.to_not raise_error
         end
       end
 
-      context "given an identifier 32 characters in length" do
-        let(:identifier) { "xxxxxxxx 32 characters xxxxxxxxx" }
+      context 'given an identifier 32 characters in length' do
+        let(:identifier) { 'xxxxxxxx 32 characters xxxxxxxxx' }
         specify do
           expect { Account.new(:identifier => identifier) }.to raise_error AccountIdentifierTooLongError, /'#{identifier}'/
         end
@@ -21,64 +20,64 @@ module DoubleEntry
     end
 
     describe Account::Instance do
-      it "is sortable" do
-        account = Account.new(:identifier => "savings", :scope_identifier => identity_scope)
-        a = Account::Instance.new(:account => account, :scope => "123")
-        b = Account::Instance.new(:account => account, :scope => "456")
+      it 'is sortable' do
+        account = Account.new(:identifier => 'savings', :scope_identifier => identity_scope)
+        a = Account::Instance.new(:account => account, :scope => '123')
+        b = Account::Instance.new(:account => account, :scope => '456')
         expect([b, a].sort).to eq [a, b]
       end
 
-      it "is hashable" do
-        account = Account.new(:identifier => "savings", :scope_identifier => identity_scope)
-        a1 = Account::Instance.new(:account => account, :scope => "123")
-        a2 = Account::Instance.new(:account => account, :scope => "123")
-        b  = Account::Instance.new(:account => account, :scope => "456")
+      it 'is hashable' do
+        account = Account.new(:identifier => 'savings', :scope_identifier => identity_scope)
+        a1 = Account::Instance.new(:account => account, :scope => '123')
+        a2 = Account::Instance.new(:account => account, :scope => '123')
+        b  = Account::Instance.new(:account => account, :scope => '456')
 
         expect(a1.hash).to eq a2.hash
         expect(a1.hash).to_not eq b.hash
       end
 
-      describe "::new" do
-        let(:account) { Account.new(:identifier => "x", :scope_identifier => identity_scope) }
+      describe '::new' do
+        let(:account) { Account.new(:identifier => 'x', :scope_identifier => identity_scope) }
         subject(:initialize_account_instance) { Account::Instance.new(:account => account, :scope => scope) }
 
-        context "given a scope identifier 23 characters in length" do
-          let(:scope) { "xxxx 23 characters xxxx" }
+        context 'given a scope identifier 23 characters in length' do
+          let(:scope) { 'xxxx 23 characters xxxx' }
           specify { expect { initialize_account_instance }.to_not raise_error }
         end
 
-        context "given a scope identifier 24 characters in length" do
-          let(:scope) { "xxxx 24 characters xxxxx" }
+        context 'given a scope identifier 24 characters in length' do
+          let(:scope) { 'xxxx 24 characters xxxxx' }
           specify { expect { initialize_account_instance }.to raise_error ScopeIdentifierTooLongError, /'#{scope}'/ }
         end
       end
     end
 
-    describe "currency" do
-      it "defaults to USD currency" do
-        account = DoubleEntry::Account.new(:identifier => "savings", :scope_identifier => identity_scope)
-        expect(DoubleEntry::Account::Instance.new(:account => account).currency).to eq("USD")
+    describe 'currency' do
+      it 'defaults to USD currency' do
+        account = DoubleEntry::Account.new(:identifier => 'savings', :scope_identifier => identity_scope)
+        expect(DoubleEntry::Account::Instance.new(:account => account).currency).to eq('USD')
       end
 
-      it "allows the currency to be set" do
-        account = DoubleEntry::Account.new(:identifier => "savings", :scope_identifier => identity_scope, :currency => "AUD")
-        expect(DoubleEntry::Account::Instance.new(:account => account).currency).to eq("AUD")
+      it 'allows the currency to be set' do
+        account = DoubleEntry::Account.new(:identifier => 'savings', :scope_identifier => identity_scope, :currency => 'AUD')
+        expect(DoubleEntry::Account::Instance.new(:account => account).currency).to eq('AUD')
       end
     end
 
     describe Account::Set do
-      describe "#define" do
+      describe '#define' do
         context "given a 'savings' account is defined" do
-          before { subject.define(:identifier => "savings") }
+          before { subject.define(:identifier => 'savings') }
           its(:first) { should be_an Account }
-          its("first.identifier") { should eq "savings" }
+          its('first.identifier') { should eq 'savings' }
         end
       end
 
-      describe "#active_record_scope_identifier" do
+      describe '#active_record_scope_identifier' do
         subject(:scope) { Account::Set.new.active_record_scope_identifier(ar_class) }
 
-        context "given ActiveRecordScopeFactory is stubbed" do
+        context 'given ActiveRecordScopeFactory is stubbed' do
           let(:scope_identifier) { double(:scope_identifier) }
           let(:scope_factory) { double(:scope_factory, :scope_identifier => scope_identifier) }
           let(:ar_class) { double(:ar_class) }
@@ -90,36 +89,36 @@ module DoubleEntry
     end
   end
 
-  describe Account::ActiveRecordScopeFactory do
-    context "given the class User" do
+  RSpec.describe Account::ActiveRecordScopeFactory do
+    context 'given the class User' do
       subject(:factory) { Account::ActiveRecordScopeFactory.new(User) }
 
-      describe "#scope_identifier" do
+      describe '#scope_identifier' do
         subject(:scope_identifier) { factory.scope_identifier }
 
-        describe "#call" do
+        describe '#call' do
           subject(:scope) { scope_identifier.call(value) }
 
-          context "given a User instance with ID 32" do
+          context 'given a User instance with ID 32' do
             let(:value) { User.make(:id => 32) }
 
             it { should eq 32 }
           end
 
-          context "given differing model instance with ID 32" do
+          context 'given differing model instance with ID 32' do
             let(:value) { double(:id => 32) }
-            it "raises an error" do
+            it 'raises an error' do
               expect { scope_identifier.call(value) }.to raise_error DoubleEntry::AccountScopeMismatchError
             end
           end
 
           context "given the String 'I am a bearded lady'" do
-            let(:value) { "I am a bearded lady" }
+            let(:value) { 'I am a bearded lady' }
 
-            it { should eq "I am a bearded lady" }
+            it { should eq 'I am a bearded lady' }
           end
 
-          context "given the Integer 42" do
+          context 'given the Integer 42' do
             let(:value) { 42 }
 
             it { should eq 42 }