double_entry 0.10.0 → 0.10.1

data/spec/double_entry/balance_calculator_spec.rb

@@ -1,10 +1,8 @@
 # encoding: utf-8
-require 'spec_helper'
-
-describe DoubleEntry::BalanceCalculator do
 
+RSpec.describe DoubleEntry::BalanceCalculator do
   describe '#calculate' do
-    let(:account) { DoubleEntry::account(:test, :scope => scope) }
+    let(:account) { DoubleEntry.account(:test, :scope => scope) }
     let(:scope) { User.make! }
     let(:from) { nil }
     let(:to) { nil }
@@ -42,7 +40,7 @@ describe DoubleEntry::BalanceCalculator do
 
           it 'ignores the time range when summing the lines' do
             expect(relation).to_not have_received(:where).with(
-              :created_at => Time.parse('2014-06-19 10:09:18 +1000')..Time.parse('2014-06-19 20:09:18 +1000')
+              :created_at => Time.parse('2014-06-19 10:09:18 +1000')..Time.parse('2014-06-19 20:09:18 +1000'),
             )
             expect(relation).to_not have_received(:sum)
           end
@@ -55,7 +53,7 @@ describe DoubleEntry::BalanceCalculator do
 
         it 'scopes the lines summed to times within the given range' do
           expect(relation).to have_received(:where).with(
-            :created_at => Time.parse('2014-06-19 10:09:18 +1000')..Time.parse('2014-06-19 20:09:18 +1000')
+            :created_at => Time.parse('2014-06-19 10:09:18 +1000')..Time.parse('2014-06-19 20:09:18 +1000'),
           )
           expect(relation).to have_received(:sum).with(:amount)
         end
@@ -72,10 +70,10 @@ describe DoubleEntry::BalanceCalculator do
     end
 
     context 'when a list of codes is provided' do
-      let(:codes) { ['code1', 'code2'] }
+      let(:codes) { %w(code1 code2) }
 
       it 'scopes the lines summed by the given codes' do
-        expect(relation).to have_received(:where).with(:code => ['code1', 'code2'])
+        expect(relation).to have_received(:where).with(:code => %w(code1 code2))
         expect(relation).to have_received(:sum).with(:amount)
       end
     end

data/spec/double_entry/configuration_spec.rb

@@ -1,28 +1,26 @@
 # encoding: utf-8
-require 'spec_helper'
-describe DoubleEntry::Configuration do
-
+RSpec.describe DoubleEntry::Configuration do
   its(:accounts) { should be_a DoubleEntry::Account::Set }
   its(:transfers) { should be_a DoubleEntry::Transfer::Set }
 
-  describe "max lengths" do
-    context "given a max length has not been set" do
+  describe 'max lengths' do
+    context 'given a max length has not been set' do
       its(:code_max_length) { should be 47 }
       its(:scope_identifier_max_length) { should be 23 }
       its(:account_identifier_max_length) { should be 31 }
     end
 
-    context "given a code max length of 10 has been set" do
+    context 'given a code max length of 10 has been set' do
       before { subject.code_max_length = 10 }
       its(:code_max_length) { should be 10 }
     end
 
-    context "given a scope identifier max length of 11 has been set" do
+    context 'given a scope identifier max length of 11 has been set' do
       before { subject.scope_identifier_max_length = 11 }
       its(:scope_identifier_max_length) { should be 11 }
     end
 
-    context "given an account identifier max length of 9 has been set" do
+    context 'given an account identifier max length of 9 has been set' do
       before { subject.account_identifier_max_length = 9 }
       its(:account_identifier_max_length) { should be 9 }
     end
@@ -34,19 +32,19 @@ describe DoubleEntry::Configuration do
     end
   end
 
-  describe "#define_accounts" do
-    it "yields the accounts set" do
-      expect { |block|
+  describe '#define_accounts' do
+    it 'yields the accounts set' do
+      expect do |block|
         subject.define_accounts(&block)
-      }.to yield_with_args(be_a DoubleEntry::Account::Set)
+      end.to yield_with_args(be_a DoubleEntry::Account::Set)
     end
   end
 
-  describe "#define_transfers" do
-    it "yields the transfers set" do
-      expect { |block|
+  describe '#define_transfers' do
+    it 'yields the transfers set' do
+      expect do |block|
         subject.define_transfers(&block)
-      }.to yield_with_args(be_a DoubleEntry::Transfer::Set)
+      end.to yield_with_args(be_a DoubleEntry::Transfer::Set)
     end
   end
 end

data/spec/double_entry/line_spec.rb

@@ -1,12 +1,11 @@
 # encoding: utf-8
-require "spec_helper"
-describe DoubleEntry::Line do
-  it "has a table name prefixed with double_entry_" do
-    expect(DoubleEntry::Line.table_name).to eq "double_entry_lines"
+RSpec.describe DoubleEntry::Line do
+  it 'has a table name prefixed with double_entry_' do
+    expect(DoubleEntry::Line.table_name).to eq 'double_entry_lines'
   end
 
-  describe "persistance" do
-    let(:line_to_persist) {
+  describe 'persistance' do
+    let(:line_to_persist) do
       DoubleEntry::Line.new(
         :amount => Money.new(10_00),
         :balance => Money.zero,
@@ -14,9 +13,9 @@ describe DoubleEntry::Line do
         :partner_account => partner_account,
         :code => code,
       )
-    }
-    let(:account) { DoubleEntry.account(:test, :scope => "17") }
-    let(:partner_account) { DoubleEntry.account(:test, :scope => "72") }
+    end
+    let(:account) { DoubleEntry.account(:test, :scope => '17') }
+    let(:partner_account) { DoubleEntry.account(:test, :scope => '72') }
     let(:code) { :test_code }
 
     subject(:persisted_line) do
@@ -24,33 +23,33 @@ describe DoubleEntry::Line do
       line_to_persist.reload
     end
 
-    describe "attributes" do
-      context "given code = :the_code" do
+    describe 'attributes' do
+      context 'given code = :the_code' do
         let(:code) { :the_code }
         its(:code) { should eq :the_code }
       end
 
-      context "given code = nil" do
+      context 'given code = nil' do
         let(:code) { nil }
         specify { expect { line_to_persist.save! }.to raise_error }
       end
 
-      context "given account = :test, 54 " do
-        let(:account) { DoubleEntry.account(:test, :scope => "54") }
-        its("account.account.identifier") { should eq :test }
-        its("account.scope") { should eq "54" }
+      context 'given account = :test, 54 ' do
+        let(:account) { DoubleEntry.account(:test, :scope => '54') }
+        its('account.account.identifier') { should eq :test }
+        its('account.scope') { should eq '54' }
       end
 
-      context "given partner_account = :test, 91 " do
-        let(:partner_account) { DoubleEntry.account(:test, :scope => "91") }
-        its("partner_account.account.identifier") { should eq :test }
-        its("partner_account.scope") { should eq "91" }
+      context 'given partner_account = :test, 91 ' do
+        let(:partner_account) { DoubleEntry.account(:test, :scope => '91') }
+        its('partner_account.account.identifier') { should eq :test }
+        its('partner_account.scope') { should eq '91' }
       end
 
-      context "currency" do
-        let(:account) { DoubleEntry.account(:btc_test, :scope => "17") }
-        let(:partner_account) { DoubleEntry.account(:btc_test, :scope => "72") }
-        its(:currency) { should eq "BTC" }
+      context 'currency' do
+        let(:account) { DoubleEntry.account(:btc_test, :scope => '17') }
+        let(:partner_account) { DoubleEntry.account(:btc_test, :scope => '72') }
+        its(:currency) { should eq 'BTC' }
       end
     end
 
@@ -74,8 +73,8 @@ describe DoubleEntry::Line do
       end
     end
 
-    it "has a table name prefixed with double_entry_" do
-      expect(DoubleEntry::Line.table_name).to eq "double_entry_lines"
+    it 'has a table name prefixed with double_entry_' do
+      expect(DoubleEntry::Line.table_name).to eq 'double_entry_lines'
     end
   end
 end

data/spec/double_entry/locking_spec.rb

@@ -1,8 +1,6 @@
 # encoding: utf-8
-require 'spec_helper'
-
-describe DoubleEntry::Locking do
 
+RSpec.describe DoubleEntry::Locking do
   before do
     @config_accounts = DoubleEntry.configuration.accounts
     @config_transfers = DoubleEntry.configuration.transfers
@@ -33,16 +31,16 @@ describe DoubleEntry::Locking do
       end
     end
 
-    @account_a = DoubleEntry.account(:account_a, :scope => "1")
-    @account_b = DoubleEntry.account(:account_b, :scope => "2")
-    @account_c = DoubleEntry.account(:account_c, :scope => "3")
-    @account_d = DoubleEntry.account(:account_d, :scope => "4")
+    @account_a = DoubleEntry.account(:account_a, :scope => '1')
+    @account_b = DoubleEntry.account(:account_b, :scope => '2')
+    @account_c = DoubleEntry.account(:account_c, :scope => '3')
+    @account_d = DoubleEntry.account(:account_d, :scope => '4')
     @account_e = DoubleEntry.account(:account_e)
   end
 
-  it "creates missing account balance records" do
+  it 'creates missing account balance records' do
     expect do
-      DoubleEntry::Locking.lock_accounts(@account_a) { }
+      DoubleEntry::Locking.lock_accounts(@account_a) {}
     end.to change(DoubleEntry::AccountBalance, :count).by(1)
 
     account_balance = DoubleEntry::AccountBalance.find_by_account(@account_a)
@@ -50,7 +48,7 @@ describe DoubleEntry::Locking do
     expect(account_balance.balance).to eq Money.new(0)
   end
 
-  it "takes 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,
       :partner_account => @account_b,
@@ -67,7 +65,7 @@ describe DoubleEntry::Locking do
     )
 
     expect do
-      DoubleEntry::Locking.lock_accounts(@account_a) { }
+      DoubleEntry::Locking.lock_accounts(@account_a) {}
     end.to change(DoubleEntry::AccountBalance, :count).by(1)
 
     account_balance = DoubleEntry::AccountBalance.find_by_account(@account_a)
@@ -75,43 +73,43 @@ describe DoubleEntry::Locking do
     expect(account_balance.balance).to eq Money.new(10_00)
   end
 
-  it "prohibits locking inside a regular transaction" do
-    expect {
+  it 'prohibits locking inside a regular transaction' do
+    expect do
       DoubleEntry::AccountBalance.transaction do
         DoubleEntry::Locking.lock_accounts(@account_a, @account_b) do
         end
       end
-    }.to raise_error(DoubleEntry::Locking::LockMustBeOutermostTransaction)
+    end.to raise_error(DoubleEntry::Locking::LockMustBeOutermostTransaction)
   end
 
-  it "prohibits a transfer inside a regular transaction" do
-    expect {
+  it 'prohibits a transfer inside a regular transaction' do
+    expect do
       DoubleEntry::AccountBalance.transaction do
         DoubleEntry.transfer(Money.new(10_00), :from => @account_a, :to => @account_b, :code => :test)
       end
-    }.to raise_error(DoubleEntry::Locking::LockMustBeOutermostTransaction)
+    end.to raise_error(DoubleEntry::Locking::LockMustBeOutermostTransaction)
   end
 
   it "allows a transfer inside a lock if we've locked the transaction accounts" do
-    expect {
+    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)
       end
-    }.to_not raise_error
+    end.to_not raise_error
   end
 
   it "does not allow a transfer inside a lock if the right locks aren't held" do
-    expect {
+    expect do
       DoubleEntry::Locking.lock_accounts(@account_a, @account_c) do
         DoubleEntry.transfer(Money.new(10_00), :from => @account_a, :to => @account_b, :code => :test)
       end
-    }.to raise_error(DoubleEntry::Locking::LockNotHeld, "No lock held for account: account_b, scope 2")
+    end.to raise_error(DoubleEntry::Locking::LockNotHeld, 'No lock held for account: account_b, scope 2')
   end
 
-  it "allows 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) { }
+        DoubleEntry::Locking.lock_accounts(@account_a, @account_b) {}
       end
     end.to_not raise_error
   end
@@ -119,15 +117,15 @@ describe DoubleEntry::Locking 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) { }
+        DoubleEntry::Locking.lock_accounts(@account_a, @account_b) {}
       end
-    end.to raise_error(DoubleEntry::Locking::LockNotHeld, "No lock held for account: account_b, scope 2")
+    end.to raise_error(DoubleEntry::Locking::LockNotHeld, 'No lock held for account: account_b, scope 2')
   end
 
-  it "rolls 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
+      fail ActiveRecord::Rollback
     end
     expect(DoubleEntry.balance(@account_a)).to eq Money.new(0)
     expect(DoubleEntry.balance(@account_b)).to eq Money.new(0)
@@ -137,27 +135,24 @@ describe DoubleEntry::Locking 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)
-        raise "Yeah, right"
+        fail 'Yeah, right'
       end
-    end.to raise_error("Yeah, right")
+    end.to raise_error('Yeah, right')
     expect(DoubleEntry.balance(@account_a)).to eq Money.new(0)
     expect(DoubleEntry.balance(@account_b)).to eq Money.new(0)
   end
 
-  it "allows locking a scoped account and a non scoped account" do
+  it 'allows locking a scoped account and a non scoped account' do
     expect do
-      DoubleEntry::Locking.lock_accounts(@account_d, @account_e) do
-        # do nothing
-      end
+      DoubleEntry::Locking.lock_accounts(@account_d, @account_e) {}
     end.to_not raise_error
   end
 
   # sqlite cannot handle these cases so they don't run when DB=sqlite
-  describe "concurrent locking", :unless => ENV['DB'] == 'sqlite' do
-
-    it "allows multiple threads to lock at the same time" do
+  describe 'concurrent locking', :unless => ENV['DB'] == 'sqlite' do
+    it 'allows multiple threads to lock at the same time' do
       expect do
-        threads = Array.new
+        threads = []
 
         threads << Thread.new do
           sleep 0.05
@@ -177,8 +172,8 @@ describe DoubleEntry::Locking do
       end.to_not raise_error
     end
 
-    it "allows multiple threads to lock accounts without balances at the same time" do
-      threads = Array.new
+    it 'allows multiple threads to lock accounts without balances at the same time' do
+      threads = []
       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 } }

data/spec/double_entry/reporting/aggregate_array_spec.rb

@@ -1,8 +1,6 @@
-require 'spec_helper'
 module DoubleEntry
   module Reporting
-    describe AggregateArray do
-
+    RSpec.describe AggregateArray do
       let(:user) { User.make! }
       let(:start) { nil }
       let(:finish) { nil }
@@ -10,7 +8,7 @@ module DoubleEntry
       let(:function) { :sum }
       let(:account) { :savings }
       let(:transfer_code) { :bonus }
-      subject(:aggregate_array) {
+      subject(:aggregate_array) do
         Reporting.aggregate_array(
           function,
           account,
@@ -19,7 +17,7 @@ module DoubleEntry
           :start => start,
           :finish => finish,
         )
-      }
+      end
 
       context 'given a deposit was made in 2007 and 2008' do
         before do
@@ -37,7 +35,7 @@ module DoubleEntry
           context 'when called with range type of "year"' do
             let(:range_type) { 'year' }
             let(:start) { '2006-08-03' }
-            it { should eq [ Money.new(0), Money.new(10_00), Money.new(20_00), Money.new(0) ] }
+            it { should eq [Money.zero, Money.new(10_00), Money.new(20_00), Money.zero] }
           end
         end
       end
@@ -56,7 +54,7 @@ module DoubleEntry
           let(:range_type) { 'month' }
           let(:start) { '2006-09-01' }
           let(:finish) { '2007-01-02' }
-          it { should eq [ Money.new(0), Money.new(10_00), Money.new(0), Money.new(20_00), Money.new(0), ] }
+          it { should eq [Money.zero, Money.new(10_00), Money.zero, Money.new(20_00), Money.zero] }
         end
 
         context 'given the date is 2007-02-02' do
@@ -65,7 +63,7 @@ module DoubleEntry
           context 'when called with range type of "month"' do
             let(:range_type) { 'month' }
             let(:start) { '2006-08-03' }
-            it { should eq [ Money.new(0), Money.new(0), Money.new(10_00), Money.new(0), Money.new(20_00), Money.new(0), Money.new(0) ] }
+            it { should eq [Money.zero, Money.zero, Money.new(10_00), Money.zero, Money.new(20_00), Money.zero, Money.zero] }
           end
         end
       end
@@ -81,7 +79,7 @@ module DoubleEntry
           perform_btc_deposit(user, 100_000_000)
         end
 
-        it { should eq [ Money.new(200_000_000, :btc) ] }
+        it { should eq [Money.new(200_000_000, :btc)] }
       end
 
       context 'when called with range type of "invalid_and_should_not_work"' do
@@ -96,7 +94,7 @@ module DoubleEntry
         let(:start) { '2006-08-03' }
         let(:function) { :invalid_function }
         it 'raises an AggregateFunctionNotSupported error' do
-          expect{ aggregate_array }.to raise_error AggregateFunctionNotSupported
+          expect { aggregate_array }.to raise_error AggregateFunctionNotSupported
         end
       end
     end

data/spec/double_entry/reporting/aggregate_spec.rb

@@ -1,9 +1,7 @@
 # encoding: utf-8
-require 'spec_helper'
 module DoubleEntry
   module Reporting
-    describe Aggregate do
-
+    RSpec.describe Aggregate do
       let(:user) { User.make! }
       let(:expected_weekly_average) do
         (Money.new(20_00) + Money.new(40_00) + Money.new(50_00)) / 3
@@ -35,64 +33,84 @@ module DoubleEntry
       end
 
       it 'should store the aggregate for quick retrieval' do
-        Reporting.aggregate(:sum, :savings, :bonus,
-                            :range => TimeRange.make(:year => 2009, :month => 10))
+        Reporting.aggregate(:sum, :savings, :bonus, :range => TimeRange.make(:year => 2009, :month => 10))
         expect(LineAggregate.count).to eq 1
       end
 
       it 'should only store the aggregate once if it is requested more than once' do
-        Reporting.aggregate(:sum, :savings, :bonus,
-                            :range => TimeRange.make(:year => 2009, :month => 9))
-        Reporting.aggregate(:sum, :savings, :bonus,
-                            :range => TimeRange.make(:year => 2009, :month => 9))
-        Reporting.aggregate(:sum, :savings, :bonus,
-                            :range => TimeRange.make(:year => 2009, :month => 10))
+        Reporting.aggregate(:sum, :savings, :bonus, :range => TimeRange.make(:year => 2009, :month => 9))
+        Reporting.aggregate(:sum, :savings, :bonus, :range => TimeRange.make(:year => 2009, :month => 9))
+        Reporting.aggregate(:sum, :savings, :bonus, :range => TimeRange.make(:year => 2009, :month => 10))
         expect(LineAggregate.count).to eq 2
       end
 
       it 'should calculate the complete year correctly' do
         expect(
-          Reporting.aggregate(:sum, :savings, :bonus, :range => TimeRange.make(:year => 2009))
+          Reporting.aggregate(
+            :sum, :savings, :bonus,
+            :range => TimeRange.make(:year => 2009)
+          ),
         ).to eq Money.new(200_00)
       end
 
       it 'should calculate seperate months correctly' do
         expect(
-          Reporting.aggregate(:sum, :savings, :bonus, :range => TimeRange.make(:year => 2009, :month => 10))
+          Reporting.aggregate(
+            :sum, :savings, :bonus,
+            :range => TimeRange.make(:year => 2009, :month => 10)
+          ),
         ).to eq Money.new(110_00)
         expect(
-          Reporting.aggregate(:sum, :savings, :bonus, :range => TimeRange.make(:year => 2009, :month => 11))
+          Reporting.aggregate(
+            :sum, :savings, :bonus,
+            :range => TimeRange.make(:year => 2009, :month => 11)
+          ),
         ).to eq Money.new(90_00)
       end
 
       it 'should calculate seperate weeks correctly' do
         # Week 40 - Mon Sep 28, 2009 to Sun Oct 4 2009
         expect(
-          Reporting.aggregate(:sum, :savings, :bonus, :range => TimeRange.make(:year => 2009, :week => 40))
+          Reporting.aggregate(
+            :sum, :savings, :bonus,
+            :range => TimeRange.make(:year => 2009, :week => 40)
+          ),
         ).to eq Money.new(60_00)
       end
 
       it 'should calculate seperate days correctly' do
         # 1 Nov 2009
         expect(
-          Reporting.aggregate(:sum, :savings, :bonus, :range => TimeRange.make(:year => 2009, :week => 44, :day => 7))
+          Reporting.aggregate(
+            :sum, :savings, :bonus,
+            :range => TimeRange.make(:year => 2009, :week => 44, :day => 7)
+          ),
         ).to eq Money.new(90_00)
       end
 
       it 'should calculate seperate hours correctly' do
         # 1 Nov 2009
         expect(
-          Reporting.aggregate(:sum, :savings, :bonus, :range => TimeRange.make(:year => 2009, :week => 44, :day => 7, :hour => 0))
+          Reporting.aggregate(
+            :sum, :savings, :bonus,
+            :range => TimeRange.make(:year => 2009, :week => 44, :day => 7, :hour => 0)
+          ),
         ).to eq Money.new(40_00)
         expect(
-          Reporting.aggregate(:sum, :savings, :bonus, :range => TimeRange.make(:year => 2009, :week => 44, :day => 7, :hour => 1))
+          Reporting.aggregate(
+            :sum, :savings, :bonus,
+            :range => TimeRange.make(:year => 2009, :week => 44, :day => 7, :hour => 1)
+          ),
         ).to eq Money.new(50_00)
       end
 
       it 'should calculate, but not store aggregates when the time range is still current' do
         Timecop.freeze Time.local(2009, 11, 21) do
           expect(
-            Reporting.aggregate(:sum, :savings, :bonus, :range => TimeRange.make(:year => 2009, :month => 11))
+            Reporting.aggregate(
+              :sum, :savings, :bonus,
+              :range => TimeRange.make(:year => 2009, :month => 11)
+            ),
           ).to eq Money.new(90_00)
           expect(LineAggregate.count).to eq 0
         end
@@ -101,7 +119,10 @@ module DoubleEntry
       it 'should calculate, but not store aggregates when the time range is in the future' do
         Timecop.freeze Time.local(2009, 11, 21) do
           expect(
-            Reporting.aggregate(:sum, :savings, :bonus, :range => TimeRange.make(:year => 2009, :month => 12))
+            Reporting.aggregate(
+              :sum, :savings, :bonus,
+              :range => TimeRange.make(:year => 2009, :month => 12)
+            ),
           ).to eq Money.new(0)
           expect(LineAggregate.count).to eq 0
         end
@@ -109,51 +130,71 @@ module DoubleEntry
 
       it 'should calculate monthly all_time ranges correctly' do
         expect(
-          Reporting.aggregate(:sum, :savings, :bonus, :range => TimeRange.make(:year => 2009, :month => 12, :range_type => :all_time))
+          Reporting.aggregate(
+            :sum, :savings, :bonus,
+            :range => TimeRange.make(:year => 2009, :month => 12, :range_type => :all_time)
+          ),
         ).to eq Money.new(200_00)
       end
 
       it 'calculates the average monthly all_time ranges correctly' do
         expect(
-          Reporting.aggregate(:average, :savings, :bonus, :range => TimeRange.make(:year => 2009, :month => 12, :range_type => :all_time))
+          Reporting.aggregate(
+            :average, :savings, :bonus,
+            :range => TimeRange.make(:year => 2009, :month => 12, :range_type => :all_time)
+          ),
         ).to eq expected_monthly_average
       end
 
       it 'returns the correct count for weekly all_time ranges correctly' do
         expect(
-          Reporting.aggregate(:count, :savings, :bonus, :range => TimeRange.make(:year => 2009, :month => 12, :range_type => :all_time))
+          Reporting.aggregate(
+            :count, :savings, :bonus,
+            :range => TimeRange.make(:year => 2009, :month => 12, :range_type => :all_time)
+          ),
         ).to eq 5
       end
 
       it 'should calculate weekly all_time ranges correctly' do
         expect(
-          Reporting.aggregate(:sum, :savings, :bonus, :range => TimeRange.make(:year => 2009, :week => 43, :range_type => :all_time))
+          Reporting.aggregate(
+            :sum, :savings, :bonus,
+            :range => TimeRange.make(:year => 2009, :week => 43, :range_type => :all_time)
+          ),
         ).to eq Money.new(110_00)
       end
 
       it 'calculates the average weekly all_time ranges correctly' do
         expect(
-          Reporting.aggregate(:average, :savings, :bonus, :range => TimeRange.make(:year => 2009, :week => 43, :range_type => :all_time))
+          Reporting.aggregate(
+            :average, :savings, :bonus,
+            :range => TimeRange.make(:year => 2009, :week => 43, :range_type => :all_time)
+          ),
         ).to eq expected_weekly_average
       end
 
       it 'returns the correct count for weekly all_time ranges correctly' do
         expect(
-          Reporting.aggregate(:count, :savings, :bonus, :range => TimeRange.make(:year => 2009, :week => 43, :range_type => :all_time))
+          Reporting.aggregate(
+            :count, :savings, :bonus,
+            :range => TimeRange.make(:year => 2009, :week => 43, :range_type => :all_time)
+          ),
         ).to eq 3
       end
 
-      it "raises an AggregateFunctionNotSupported exception" do
-        expect{
-          Reporting.aggregate(:not_supported_calculation, :savings, :bonus, :range => TimeRange.make(:year => 2009, :week => 43, :range_type => :all_time))
-        }.to raise_error(AggregateFunctionNotSupported)
+      it 'raises an AggregateFunctionNotSupported exception' do
+        expect do
+          Reporting.aggregate(
+            :not_supported_calculation, :savings, :bonus,
+            :range => TimeRange.make(:year => 2009, :week => 43, :range_type => :all_time)
+          )
+        end.to raise_error(AggregateFunctionNotSupported)
       end
 
       context 'filters' do
-
         let(:range) { TimeRange.make(:year => 2011, :month => 10) }
 
-        class ::DoubleEntry::Line
+        DoubleEntry::Line.class_eval do
           scope :test_filter, -> { where(:amount => 10_00) }
         end
 
@@ -168,42 +209,41 @@ module DoubleEntry
         end
 
         it 'saves filtered aggregations' do
-          expect {
+          expect do
             Reporting.aggregate(:sum, :savings, :bonus, :range => range, :filter => [:test_filter])
-          }.to change { LineAggregate.count }.by 1
+          end.to change { LineAggregate.count }.by 1
         end
 
         it 'saves filtered aggregation only once for a range' do
-          expect {
+          expect do
             Reporting.aggregate(:sum, :savings, :bonus, :range => range, :filter => [:test_filter])
             Reporting.aggregate(:sum, :savings, :bonus, :range => range, :filter => [:test_filter])
-          }.to change { LineAggregate.count }.by 1
+          end.to change { LineAggregate.count }.by 1
         end
 
         it 'saves filtered aggregations and non filtered aggregations separately' do
-          expect {
+          expect do
             Reporting.aggregate(:sum, :savings, :bonus, :range => range, :filter => [:test_filter])
             Reporting.aggregate(:sum, :savings, :bonus, :range => range)
-          }.to change { LineAggregate.count }.by 2
+          end.to change { LineAggregate.count }.by 2
         end
 
         it 'loads the correct saved aggregation' do
-
           # cache the results for filtered and unfiltered aggregations
           Reporting.aggregate(:sum, :savings, :bonus, :range => range, :filter => [:test_filter])
           Reporting.aggregate(:sum, :savings, :bonus, :range => range)
 
           # ensure a second call loads the correct cached value
           expect(
-            Reporting.aggregate(:sum, :savings, :bonus, :range  => range, :filter => [:test_filter])
+            Reporting.aggregate(:sum, :savings, :bonus, :range  => range, :filter => [:test_filter]),
           ).to eq Money.new(10_00)
           expect(
-            Reporting.aggregate(:sum, :savings, :bonus, :range  => range)
+            Reporting.aggregate(:sum, :savings, :bonus, :range  => range),
           ).to eq Money.new(19_00)
         end
       end
     end
-    describe Aggregate, "currencies" do
+    RSpec.describe Aggregate, 'currencies' do
       let(:user) { User.make! }
       before do
         perform_btc_deposit(user, 100_000_000)
@@ -212,8 +252,8 @@ module DoubleEntry
 
       it 'should calculate the sum in the correct currency' do
         expect(
-          Reporting.aggregate(:sum, :btc_savings, :btc_test_transfer, :range => TimeRange.make(:year => Time.now.year))
-        ).to eq Money.new(300_000_000, :btc)
+          Reporting.aggregate(:sum, :btc_savings, :btc_test_transfer, :range => TimeRange.make(:year => Time.now.year)),
+        ).to eq(Money.new(300_000_000, :btc))
       end
     end
   end