double_entry 0.4.0 → 0.5.0

data/.gitignore

@@ -16,6 +16,7 @@ spec/support/database.yml
 test/tmp
 test/version_tmp
 tmp
+db/*.sqlite3
 bin/
 log/
 /Gemfile.lock

data/.travis.yml

@@ -6,6 +6,7 @@ rvm:
 env:
   - DB=mysql
   - DB=postgres
+  - DB=sqlite
 before_script:
   - cp spec/support/database.travis.yml spec/support/database.yml
   - mysql -e 'create database double_entry_test;'

data/README.md

@@ -169,14 +169,7 @@ require 'double_entry'
 
 DoubleEntry.configure do |config|
   config.define_accounts do |accounts|
-    user_scope = lambda do |user_identifier|
-      if user_identifier.is_a?(User)
-        user_identifier.id
-      else
-        user_identifier
-      end
-    end
-
+    user_scope = accounts.active_record_scope_identifier(User)
     accounts.define(:identifier => :savings,  :scope_identifier => user_scope, :positive_only => true)
     accounts.define(:identifier => :checking, :scope_identifier => user_scope)
   end

data/Rakefile

@@ -6,7 +6,7 @@ RSpec::Core::RakeTask.new(:spec) do |t|
 end
 
 task :default do
-  %w(mysql postgres).each do |db|
+  %w(mysql postgres sqlite).each do |db|
     puts "Running tests with `DB=#{db}`"
     ENV['DB'] = db
     Rake::Task["spec"].execute

data/double_entry.gemspec

@@ -28,6 +28,7 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'mysql2'
   gem.add_development_dependency 'pg'
+  gem.add_development_dependency 'sqlite3'
   gem.add_development_dependency 'rspec'
   gem.add_development_dependency 'rspec-its'
   gem.add_development_dependency 'database_cleaner'

data/lib/active_record/locking_extensions.rb

@@ -20,7 +20,7 @@ module ActiveRecord
       begin
         yield
       rescue ActiveRecord::StatementInvalid => exception
-        if exception.message =~ /deadlock/i
+        if exception.message =~ /deadlock/i || exception.message =~ /database is locked/i
           raise ActiveRecord::RestartTransaction
         else
           raise
@@ -29,18 +29,41 @@ module ActiveRecord
     end
 
     # Create the record, but ignore the exception if there's a duplicate.
+    # if there is a deadlock, retry
     def create_ignoring_duplicates!(*args)
+      retry_deadlocks do
+        ignoring_duplicates do
+          create!(*args)
+        end
+      end
+    end
+
+    private
+
+    def ignoring_duplicates
       # Error examples:
-      #   PG::Error: ERROR:  deadlock detected
-      #   Mysql::Error: Deadlock found when trying to get lock
       #   PG::Error: ERROR:  duplicate key value violates unique constraint
       #   Mysql2::Error: Duplicate entry 'keith' for key 'index_users_on_username': INSERT INTO `users...
+      #   ActiveRecord::RecordNotUnique  SQLite3::ConstraintException: column username is not unique: INSERT INTO "users"...
       begin
-        create!(*args)
-      rescue ActiveRecord::StatementInvalid => exception
-        if  exception.message =~ /duplicate/i
+        yield
+      rescue ActiveRecord::StatementInvalid, ActiveRecord::RecordNotUnique => exception
+        if  exception.message =~ /duplicate/i || exception.message =~ /(is|are) not unique/i
           # Just ignore it...someone else has already created the record.
-        elsif  exception.message =~ /deadlock/i
+        else
+          raise
+        end
+      end
+    end
+
+    def retry_deadlocks
+      # Error examples:
+      #   PG::Error: ERROR:  deadlock detected
+      #   Mysql::Error: Deadlock found when trying to get lock
+      begin
+        yield
+      rescue ActiveRecord::StatementInvalid, ActiveRecord::RecordNotUnique => exception
+        if exception.message =~ /deadlock/i || exception.message =~ /database is locked/i
           # Somebody else is in the midst of creating the record. We'd better
           # retry, so we ensure they're done before we move on.
           retry
@@ -49,7 +72,6 @@ module ActiveRecord
         end
       end
     end
-
   end
 
   # Raise this inside a restartable_transaction to retry the transaction from the beginning.

data/lib/double_entry/account.rb

@@ -29,23 +29,30 @@ module DoubleEntry
           super(account)
         end
       end
+
+      def active_record_scope_identifier(active_record_class)
+        ActiveRecordScopeFactory.new(active_record_class).scope_identifier
+      end
+    end
+
+    class ActiveRecordScopeFactory
+      def initialize(active_record_class)
+        @active_record_class = active_record_class
+      end
+
+      def scope_identifier
+        ->(value) { value.is_a?(@active_record_class) ? value.id : value }
+      end
     end
 
     class Instance
       attr_accessor :account, :scope
+      delegate :identifier, :scope_identifier, :scoped?, :positive_only, :to => :account
 
       def initialize(attributes)
         attributes.each { |name, value| send("#{name}=", value) }
       end
 
-      def method_missing(method, *args)
-        if block_given?
-          account.send(method, *args, &Proc.new)
-        else
-          account.send(method, *args)
-        end
-      end
-
       def scope_identity
         scope_identifier.call(scope).to_s if scoped?
       end

data/lib/double_entry/errors.rb

@@ -4,10 +4,8 @@ module DoubleEntry
   class UnknownAccount < RuntimeError; end
   class TransferNotAllowed < RuntimeError; end
   class TransferIsNegative < RuntimeError; end
-  class RequiredMetaMissing < RuntimeError; end
   class DuplicateAccount < RuntimeError; end
   class DuplicateTransfer < RuntimeError; end
-  class UserAccountNotLocked < RuntimeError; end
   class AccountWouldBeSentNegative < RuntimeError; end
 
 end

data/lib/double_entry/reporting.rb

@@ -150,7 +150,8 @@ module DoubleEntry
     #   which they always should.
     #
     def reconciled?(account)
-      scoped_lines = Line.where(:account => "#{account.identifier}", :scope => "#{account.scope}")
+      scoped_lines = Line.where(:account => "#{account.identifier}")
+      scoped_lines = scoped_lines.where(:scope => "#{account.scope_identity}") if account.scoped?
       sum_of_amounts = scoped_lines.sum(:amount)
       final_balance  = scoped_lines.order(:id).last[:balance]
       cached_balance = AccountBalance.find_by_account(account)[:balance]

data/lib/double_entry/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module DoubleEntry
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/script/jack_hammer

@@ -18,8 +18,14 @@ require 'database_cleaner'
 
 support = File.expand_path("../../spec/support/", __FILE__)
 
-ENV['DB'] ||= 'mysql'
-ActiveRecord::Base.establish_connection YAML.load_file(File.join(support, "database.yml"))[ENV['DB']]
+db_engine = ENV['DB'] || 'mysql'
+
+if db_engine == 'sqlite'
+  puts "Skipping jackhammer for SQLITE..."
+  exit 0
+end
+
+ActiveRecord::Base.establish_connection YAML.load_file(File.join(support, "database.yml"))[db_engine]
 require "#{support}/schema"
 
 lib = File.expand_path('../../lib', __FILE__)

data/spec/active_record/locking_extensions_spec.rb

@@ -4,6 +4,7 @@ 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...")
 
   context "#restartable_transaction" do
     it "keeps running the lock until a ActiveRecord::RestartTransaction isn't raised" do
@@ -49,6 +50,13 @@ describe ActiveRecord::LockingExtensions do
 
         expect { User.create_ignoring_duplicates! }.to_not raise_error
       end
+
+      it "in sqlite3" do
+        expect(User).to receive(:create!).ordered.and_raise(SQLITE3_LOCK)
+        expect(User).to receive(:create!).ordered.and_return(true)
+
+        expect { User.create_ignoring_duplicates! }.to_not raise_error
+      end
     end
   end
 end

data/spec/double_entry/account_spec.rb

@@ -1,32 +1,79 @@
 # encoding: utf-8
 require 'spec_helper'
-describe DoubleEntry::Account do
-  let(:empty_scope) { lambda {|value| value } }
-
-  it "instances should be sortable" do
-    account = DoubleEntry::Account.new(:identifier => "savings", :scope_identifier => empty_scope)
-    a = DoubleEntry::Account::Instance.new(:account => account, :scope => "123")
-    b = DoubleEntry::Account::Instance.new(:account => account, :scope => "456")
-    expect([b, a].sort).to eq [a, b]
+module DoubleEntry
+  describe Account do
+    let(:identity_scope) { ->(value) { value } }
+
+    it "instances should be 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 "instances should be 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
   end
 
-  it "instances should be hashable" do
-    account = DoubleEntry::Account.new(:identifier => "savings", :scope_identifier => empty_scope)
-    a1 = DoubleEntry::Account::Instance.new(:account => account, :scope => "123")
-    a2 = DoubleEntry::Account::Instance.new(:account => account, :scope => "123")
-    b  = DoubleEntry::Account::Instance.new(:account => account, :scope => "456")
+  describe Account::Set do
+    describe "#define" do
+      context "given a 'savings' account is defined" do
+        before { subject.define(:identifier => "savings") }
+        its(:first) { should be_a Account }
+        its("first.identifier") { should eq "savings" }
+      end
+    end
+
+    describe "#active_record_scope_identifier" do
+      subject(:scope) { Account::Set.new.active_record_scope_identifier(ar_class) }
 
-    expect(a1.hash).to eq a2.hash
-    expect(a1.hash).to_not eq b.hash
+      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) }
+        before { allow(Account::ActiveRecordScopeFactory).to receive(:new).with(ar_class).and_return(scope_factory) }
+
+        it { should eq scope_identifier }
+      end
+    end
   end
-end
 
-describe DoubleEntry::Account::Set do
-  describe "#define" do
-    context "given a 'savings' account is defined" do
-      before { subject.define(:identifier => "savings") }
-      its(:first) { should be_a DoubleEntry::Account }
-      its("first.identifier") { should eq "savings" }
+  describe Account::ActiveRecordScopeFactory do
+    context "given the class User" do
+      subject(:factory) { Account::ActiveRecordScopeFactory.new(User) }
+
+      describe "#scope_identifier" do
+        subject(:scope_identifier) { factory.scope_identifier }
+
+        describe "#call" do
+          subject(:scope) { scope_identifier.call(value) }
+
+          context "given a User instance with ID 32" do
+            let(:value) { User.make(:id => 32) }
+
+            it { should eq 32 }
+          end
+
+          context "given the String 'I am a bearded lady'" do
+            let(:value) { "I am a bearded lady" }
+
+            it { should eq "I am a bearded lady" }
+          end
+
+          context "given the Integer 42" do
+            let(:value) { 42 }
+
+            it { should eq 42 }
+          end
+        end
+      end
     end
   end
 end

data/spec/double_entry/locking_spec.rb

@@ -38,7 +38,7 @@ describe DoubleEntry::Locking do
     @account_d = DoubleEntry.account(:account_d, :scope => "4")
   end
 
-  it "should create missing account balance records" do
+  it "creates missing account balance records" do
     expect do
       DoubleEntry::Locking.lock_accounts(@account_a) { }
     end.to change(DoubleEntry::AccountBalance, :count).by(1)
@@ -48,7 +48,7 @@ describe DoubleEntry::Locking do
     expect(account_balance.balance).to eq Money.new(0)
   end
 
-  it "should take the balance for new account balance records from the lines table" do
+  it "takes the balance for new account balance records from the lines table" do
     DoubleEntry::Line.create!(:account => @account_a, :amount => Money.new(3_00), :balance => Money.new( 3_00), :code => :test)
     DoubleEntry::Line.create!(:account => @account_a, :amount => Money.new(7_00), :balance => Money.new(10_00), :code => :test)
 
@@ -61,7 +61,7 @@ describe DoubleEntry::Locking do
     expect(account_balance.balance).to eq Money.new(10_00)
   end
 
-  it "should not allow locking inside a regular transaction" do
+  it "prohibits locking inside a regular transaction" do
     expect {
       DoubleEntry::AccountBalance.transaction do
         DoubleEntry::Locking.lock_accounts(@account_a, @account_b) do
@@ -70,7 +70,7 @@ describe DoubleEntry::Locking do
     }.to raise_error(DoubleEntry::Locking::LockMustBeOutermostTransaction)
   end
 
-  it "should not allow a transfer inside a regular transaction" do
+  it "prohibits a transfer inside a regular transaction" do
     expect {
       DoubleEntry::AccountBalance.transaction do
         DoubleEntry.transfer(Money.new(10_00), :from => @account_a, :to => @account_b, :code => :test)
@@ -78,7 +78,7 @@ describe DoubleEntry::Locking do
     }.to raise_error(DoubleEntry::Locking::LockMustBeOutermostTransaction)
   end
 
-  it "should allow a transfer inside a lock if we've locked the transaction accounts" do
+  it "allows a transfer inside a lock if we've locked the transaction accounts" do
     expect {
       DoubleEntry::Locking.lock_accounts(@account_a, @account_b) do
         DoubleEntry.transfer(Money.new(10_00), :from => @account_a, :to => @account_b, :code => :test)
@@ -86,7 +86,7 @@ describe DoubleEntry::Locking do
     }.to_not raise_error
   end
 
-  it "should not allow a transfer inside a lock if the right locks aren't held" do
+  it "does not allow a transfer inside a lock if the right locks aren't held" do
     expect {
       DoubleEntry::Locking.lock_accounts(@account_a, @account_c) do
         DoubleEntry.transfer(Money.new(10_00), :from => @account_a, :to => @account_b, :code => :test)
@@ -94,7 +94,7 @@ describe DoubleEntry::Locking do
     }.to raise_error(DoubleEntry::Locking::LockNotHeld, "No lock held for account: account_b, scope 2")
   end
 
-  it "should allow nested locks if the outer lock locks all the accounts" do
+  it "allows nested locks if the outer lock locks all the accounts" do
     expect do
       DoubleEntry::Locking.lock_accounts(@account_a, @account_b) do
         DoubleEntry::Locking.lock_accounts(@account_a, @account_b) { }
@@ -102,7 +102,7 @@ describe DoubleEntry::Locking do
     end.to_not raise_error
   end
 
-  it "should not allow nested locks if the out lock doesn't lock all the accounts" do
+  it "prohibits nested locks if the out lock doesn't lock all the accounts" do
     expect do
       DoubleEntry::Locking.lock_accounts(@account_a) do
         DoubleEntry::Locking.lock_accounts(@account_a, @account_b) { }
@@ -110,7 +110,7 @@ describe DoubleEntry::Locking do
     end.to raise_error(DoubleEntry::Locking::LockNotHeld, "No lock held for account: account_b, scope 2")
   end
 
-  it "should roll back a locking transaction" do
+  it "rolls back a locking transaction" do
     DoubleEntry::Locking.lock_accounts(@account_a, @account_b) do
       DoubleEntry.transfer(Money.new(10_00), :from => @account_a, :to => @account_b, :code => :test)
       raise ActiveRecord::Rollback
@@ -119,7 +119,7 @@ describe DoubleEntry::Locking do
     expect(DoubleEntry.balance(@account_b)).to eq Money.new(0)
   end
 
-  it "should roll back a locking transaction if there's an exception" do
+  it "rolls back a locking transaction if there's an exception" do
     expect do
       DoubleEntry::Locking.lock_accounts(@account_a, @account_b) do
         DoubleEntry.transfer(Money.new(10_00), :from => @account_a, :to => @account_b, :code => :test)
@@ -130,36 +130,39 @@ describe DoubleEntry::Locking do
     expect(DoubleEntry.balance(@account_b)).to eq Money.new(0)
   end
 
-  it "should allow multiple threads to lock at the same time" do
-    threads = Array.new
+  # sqlite cannot handle these cases so they don't run when DB=sqlite
+  describe "concurrent locking", :unless => ENV['DB'] == 'sqlite' do
 
-    expect do
-      threads << Thread.new do
-        sleep 0.05
-        DoubleEntry::Locking.lock_accounts(@account_a, @account_b) do
-          DoubleEntry.transfer(Money.new(10_00), :from => @account_a, :to => @account_b, :code => :test)
-        end
-      end
+    it "allows multiple threads to lock at the same time" do
+      expect do
+        threads = Array.new
 
-      threads << Thread.new do
-        DoubleEntry::Locking.lock_accounts(@account_c, @account_d) do
-          sleep 0.1
-          DoubleEntry.transfer(Money.new(10_00), :from => @account_c, :to => @account_d, :code => :test)
+        threads << Thread.new do
+          sleep 0.05
+          DoubleEntry::Locking.lock_accounts(@account_a, @account_b) do
+            DoubleEntry.transfer(Money.new(10_00), :from => @account_a, :to => @account_b, :code => :test)
+          end
         end
-      end
 
-      threads.each(&:join)
-    end.to_not raise_error
-  end
+        threads << Thread.new do
+          DoubleEntry::Locking.lock_accounts(@account_c, @account_d) do
+            sleep 0.1
+            DoubleEntry.transfer(Money.new(10_00), :from => @account_c, :to => @account_d, :code => :test)
+          end
+        end
 
-  it "should allow multiple threads to lock accounts without balances at the same time" do
-    threads         = Array.new
+        threads.each(&:join)
+      end.to_not raise_error
+    end
 
-    expect do
-      threads << Thread.new { DoubleEntry::Locking.lock_accounts(@account_a, @account_b) { } }
-      threads << Thread.new { DoubleEntry::Locking.lock_accounts(@account_c, @account_d) { } }
+    it "allows multiple threads to lock accounts without balances at the same time" do
+      threads = Array.new
+      expect do
+        threads << Thread.new { DoubleEntry::Locking.lock_accounts(@account_a, @account_b) { sleep 0.1 } }
+        threads << Thread.new { DoubleEntry::Locking.lock_accounts(@account_c, @account_d) { sleep 0.1 } }
 
-      threads.each(&:join)
-    end.to_not raise_error
+        threads.each(&:join)
+      end.to_not raise_error
+    end
   end
 end

data/spec/spec_helper.rb

@@ -3,8 +3,9 @@ require 'bundler/setup'
 require 'active_record'
 require 'active_support'
 
-ENV['DB'] ||= 'mysql'
-ActiveRecord::Base.establish_connection YAML.load_file(File.expand_path("../support/database.yml", __FILE__))[ENV['DB']]
+db_engine = ENV['DB'] || 'mysql'
+
+ActiveRecord::Base.establish_connection YAML.load_file(File.expand_path("../support/database.yml", __FILE__))[db_engine]
 
 FileUtils.mkdir_p 'log'
 FileUtils.rm 'log/test.log', :force => true

data/spec/support/accounts.rb

@@ -1,16 +1,10 @@
 # encoding: utf-8
-user_scope = lambda do |user_identifier|
-  if user_identifier.is_a?(User)
-    user_identifier.id
-  else
-    user_identifier
-  end
-end
-
+require_relative 'blueprints'
 DoubleEntry.configure do |config|
 
   # A set of accounts to test with
   config.define_accounts do |accounts|
+    user_scope = accounts.active_record_scope_identifier(User)
     accounts.define(:identifier => :savings,  :scope_identifier => user_scope, :positive_only => true)
     accounts.define(:identifier => :checking, :scope_identifier => user_scope, :positive_only => true)
     accounts.define(:identifier => :test,     :scope_identifier => user_scope)

data/spec/support/database.example.yml

@@ -14,3 +14,8 @@ mysql:
   pool: 100
   username: root
   password:
+sqlite:
+  adapter: sqlite3
+  encoding: utf8
+  database: db/double_entry_test.sqlite3
+  pool: 100

data/spec/support/database.travis.yml

@@ -16,3 +16,9 @@ postgres:
   pool: 100
   timeout: 5000
   host: localhost
+
+sqlite:
+  adapter: sqlite3
+  encoding: utf8
+  database: db/double_entry_test.sqlite3
+  pool: 100

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: double_entry
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -16,7 +16,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-17 00:00:00.000000000 Z
+date: 2014-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: money
@@ -146,6 +146,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -264,6 +280,7 @@ files:
 - LICENSE.md
 - README.md
 - Rakefile
+- db/.gitkeep
 - double_entry.gemspec
 - gemfiles/Gemfile.rails-3.2.0
 - gemfiles/Gemfile.rails-4.0.0