double_entry 0.1.0 → 0.2.0

data/lib/double_entry/{time_range_array.rb → reporting/time_range_array.rb}

@@ -1,5 +1,6 @@
 # encoding: utf-8
 module DoubleEntry
+ module Reporting
   class TimeRangeArray
     class << self
 
@@ -40,4 +41,5 @@ module DoubleEntry
       end
     end
   end
+ end
 end

data/lib/double_entry/{week_range.rb → reporting/week_range.rb}

@@ -1,5 +1,6 @@
 # encoding: utf-8
 module DoubleEntry
+ module Reporting
   # We use a particularly crazy week numbering system: week 1 of any given year
   # is the first week with any days that fall into that year.
   #
@@ -43,7 +44,7 @@ module DoubleEntry
       end
 
       def earliest_week
-        from_time(DoubleEntry::Reporting.configuration.start_of_business)
+        from_time(Reporting.configuration.start_of_business)
       end
     end
 
@@ -96,4 +97,5 @@ module DoubleEntry
       self.class.send(:start_of_year, year) + (week - 1).weeks
     end
   end
+ end
 end

data/lib/double_entry/{year_range.rb → reporting/year_range.rb}

@@ -1,6 +1,6 @@
 # encoding: utf-8
-
 module DoubleEntry
+ module Reporting
   class YearRange < TimeRange
     attr_reader :year
 
@@ -13,11 +13,11 @@ module DoubleEntry
     end
 
     def self.current
-      YearRange.new(:year => Time.now.year)
+      new(:year => Time.now.year)
     end
 
     def self.from_time(time)
-      YearRange.new(:year => time.year)
+      new(:year => time.year)
     end
 
     def ==(other)
@@ -36,4 +36,5 @@ module DoubleEntry
       year.to_s
     end
   end
+ end
 end

data/lib/double_entry/transfer.rb

@@ -2,6 +2,10 @@
 module DoubleEntry
   class Transfer
     class Set < Array
+      def define(attributes)
+        self << Transfer.new(attributes)
+      end
+
       def find(from, to, code)
         _find(from.identifier, to.identifier, code)
       end

data/lib/double_entry/validation.rb

@@ -0,0 +1 @@
+require 'double_entry/validation/line_check'

data/lib/double_entry/{line_check.rb → validation/line_check.rb}

@@ -2,6 +2,7 @@
 require 'set'
 
 module DoubleEntry
+ module Validation
   class LineCheck < ActiveRecord::Base
     extend EncapsulateAsMoney
 
@@ -115,4 +116,5 @@ module DoubleEntry
       account_balance.update_attribute(:balance, balance)
     end
   end
+ end
 end

data/lib/double_entry/version.rb

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

data/script/jack_hammer

@@ -68,24 +68,29 @@ end
 def create_accounts_and_transfers
   puts "Setting up #{$account_count} accounts..."
 
-  # Create the accounts.
-  scope = lambda {|x| x }
-  DoubleEntry.accounts = DoubleEntry::Account::Set.new
-  $account_count.times do |i|
-    DoubleEntry.accounts << DoubleEntry::Account.new(:identifier => :"account-#{i}", :scope_identifier => scope)
-  end
+  DoubleEntry.configure do |config|
 
-  # Create all the possible transfers.
-  DoubleEntry.transfers = DoubleEntry::Transfer::Set.new
-  DoubleEntry.accounts.each do |from|
-    DoubleEntry.accounts.each do |to|
-      DoubleEntry.transfers << DoubleEntry::Transfer.new(:from => from.identifier, :to => to.identifier, :code => :test)
+    # Create the accounts.
+    config.define_accounts do |accounts|
+      scope = ->(x) { x }
+      $account_count.times do |i|
+        accounts.define(:identifier => :"account-#{i}", :scope_identifier => scope)
+      end
+    end
+
+    # Create all the possible transfers.
+    config.define_transfers do |transfers|
+      config.accounts.each do |from|
+        config.accounts.each do |to|
+          transfers.define(:from => from.identifier, :to => to.identifier, :code => :test)
+        end
+      end
     end
-  end
 
-  # Find account instances so we have something to work with.
-  $accounts = DoubleEntry.accounts.map do |account|
-    DoubleEntry.account(account.identifier, :scope => 1)
+    # Find account instances so we have something to work with.
+    $accounts = config.accounts.map do |account|
+      DoubleEntry.account(account.identifier, :scope => 1)
+    end
   end
 end
 
@@ -93,7 +98,7 @@ end
 def run_tests
   puts "Spawning #{$process_count} processes..."
 
-  iterations_per_process = $transfer_count / $process_count / $balance_flush_count
+  iterations_per_process = [ ($transfer_count / $process_count / $balance_flush_count), 1 ].max
 
   $balance_flush_count.times do
     puts "Flushing balances"

data/spec/double_entry/account_spec.rb

@@ -19,5 +19,14 @@ describe DoubleEntry::Account do
     expect(a1.hash).to eq a2.hash
     expect(a1.hash).to_not eq b.hash
   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" }
+    end
+  end
 end

data/spec/double_entry/configuration_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+require 'spec_helper'
+describe DoubleEntry::Configuration do
+
+  its(:accounts) { should be_a DoubleEntry::Account::Set }
+  its(:transfers) { should be_a DoubleEntry::Transfer::Set }
+
+  describe "#define_accounts" do
+    it "yields the accounts set" do
+      expect { |block|
+        subject.define_accounts(&block)
+      }.to yield_with_args(be_a DoubleEntry::Account::Set)
+    end
+  end
+
+  describe "#define_transfers" do
+    it "yields the transfers set" do
+      expect { |block|
+        subject.define_transfers(&block)
+      }.to yield_with_args(be_a DoubleEntry::Transfer::Set)
+    end
+  end
+end

data/spec/double_entry/locking_spec.rb

@@ -3,22 +3,33 @@ require 'spec_helper'
 
 describe DoubleEntry::Locking do
 
-  before(:all) { @saved_accounts,   @saved_transfers   = DoubleEntry.accounts, DoubleEntry.transfers }
-  after(:all)  { DoubleEntry.accounts, DoubleEntry.transfers = @saved_accounts,   @saved_transfers   }
-
   before do
-    scope = lambda {|x| x }
+    @config_accounts = DoubleEntry.configuration.accounts
+    @config_transfers = DoubleEntry.configuration.transfers
+    DoubleEntry.configuration.accounts = DoubleEntry::Account::Set.new
+    DoubleEntry.configuration.transfers = DoubleEntry::Transfer::Set.new
+  end
 
-    DoubleEntry.accounts = DoubleEntry::Account::Set.new.tap do |accounts|
-      accounts << DoubleEntry::Account.new(:identifier => :account_a, :scope_identifier => scope)
-      accounts << DoubleEntry::Account.new(:identifier => :account_b, :scope_identifier => scope)
-      accounts << DoubleEntry::Account.new(:identifier => :account_c, :scope_identifier => scope)
-      accounts << DoubleEntry::Account.new(:identifier => :account_d, :scope_identifier => scope)
-    end
+  after do
+    DoubleEntry.configuration.accounts = @config_accounts
+    DoubleEntry.configuration.transfers = @config_transfers
+  end
 
-    DoubleEntry.transfers = DoubleEntry::Transfer::Set.new.tap do |transfers|
-      transfers << DoubleEntry::Transfer.new(:from => :account_a, :to => :account_b, :code => :test)
-      transfers << DoubleEntry::Transfer.new(:from => :account_c, :to => :account_d, :code => :test)
+  before do
+    scope = ->(x) { x }
+
+    DoubleEntry.configure do |config|
+      config.define_accounts do |accounts|
+        accounts.define(:identifier => :account_a, :scope_identifier => scope)
+        accounts.define(:identifier => :account_b, :scope_identifier => scope)
+        accounts.define(:identifier => :account_c, :scope_identifier => scope)
+        accounts.define(:identifier => :account_d, :scope_identifier => scope)
+      end
+
+      config.define_transfers do |transfers|
+        transfers.define(:from => :account_a, :to => :account_b, :code => :test)
+        transfers.define(:from => :account_c, :to => :account_d, :code => :test)
+      end
     end
 
     @account_a = DoubleEntry.account(:account_a, :scope => "1")

data/spec/double_entry/{aggregate_array_spec.rb → reporting/aggregate_array_spec.rb}

@@ -1,5 +1,5 @@
 require 'spec_helper'
-describe DoubleEntry::AggregateArray do
+describe DoubleEntry::Reporting::AggregateArray do
 
   let(:user) { User.make! }
   let(:start) { nil }
@@ -7,7 +7,7 @@ describe DoubleEntry::AggregateArray do
   let(:range_type) { 'year' }
 
   subject(:aggregate_array) {
-    DoubleEntry.aggregate_array(
+    DoubleEntry::Reporting.aggregate_array(
       :sum,
       :savings,
       :bonus,

data/spec/double_entry/reporting/aggregate_spec.rb

@@ -0,0 +1,171 @@
+# encoding: utf-8
+require 'spec_helper'
+module DoubleEntry
+  module Reporting
+    describe Aggregate do
+
+      let(:user) { User.make! }
+
+      before do
+        # Thursday
+        Timecop.freeze Time.local(2009, 10, 1) do
+          perform_deposit user, 20_00
+        end
+
+        # Saturday
+        Timecop.freeze Time.local(2009, 10, 3) do
+          perform_deposit user, 40_00
+        end
+
+        Timecop.freeze Time.local(2009, 10, 10) do
+          perform_deposit user, 50_00
+        end
+        Timecop.freeze Time.local(2009, 11, 1, 0, 59, 0) do
+          perform_deposit user, 40_00
+        end
+        Timecop.freeze Time.local(2009, 11, 1, 1, 00, 0) do
+          perform_deposit user, 50_00
+        end
+      end
+
+      it 'should store the aggregate for quick retrieval' do
+        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))
+        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))
+        ).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))
+        ).to eq Money.new(110_00)
+        expect(
+          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))
+        ).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))
+        ).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))
+        ).to eq Money.new(40_00)
+        expect(
+          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))
+          ).to eq Money.new(90_00)
+          expect(LineAggregate.count).to eq 0
+        end
+      end
+
+      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))
+          ).to eq Money.new(0)
+          expect(LineAggregate.count).to eq 0
+        end
+      end
+
+      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))
+        ).to eq Money.new(200_00)
+      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))
+        ).to eq Money.new(110_00)
+      end
+
+      context 'filters' do
+
+        let(:range) { TimeRange.make(:year => 2011, :month => 10) }
+
+        class ::DoubleEntry::Line
+          scope :test_filter, -> { where(:amount => 10_00) }
+        end
+
+        before do
+          Timecop.freeze Time.local(2011, 10, 10) do
+            perform_deposit user, 10_00
+          end
+
+          Timecop.freeze Time.local(2011, 10, 10) do
+            perform_deposit user, 9_00
+          end
+        end
+
+        it 'saves filtered aggregations' do
+          expect {
+            Reporting.aggregate(:sum, :savings, :bonus, :range => range, :filter => [:test_filter])
+          }.to change { LineAggregate.count }.by 1
+        end
+
+        it 'saves filtered aggregation only once for a range' do
+          expect {
+            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
+
+        it 'saves filtered aggregations and non filtered aggregations separately' do
+          expect {
+            Reporting.aggregate(:sum, :savings, :bonus, :range => range, :filter => [:test_filter])
+            Reporting.aggregate(:sum, :savings, :bonus, :range => range)
+          }.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])
+          ).to eq Money.new(10_00)
+          expect(
+            Reporting.aggregate(:sum, :savings, :bonus, :range  => range)
+          ).to eq Money.new(19_00)
+        end
+      end
+    end
+  end
+end

data/spec/double_entry/reporting/line_aggregate_spec.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+require 'spec_helper'
+module DoubleEntry::Reporting
+  describe LineAggregate do
+
+    it "has a table name prefixed with double_entry_" do
+      expect(LineAggregate.table_name).to eq "double_entry_line_aggregates"
+    end
+  end
+end

data/spec/double_entry/{month_range_spec.rb → reporting/month_range_spec.rb}

@@ -1,9 +1,10 @@
 # encoding: utf-8
 require "spec_helper"
-describe DoubleEntry::MonthRange do
+module DoubleEntry::Reporting
+  describe MonthRange do
 
   describe "::from_time" do
-    subject(:from_time) { DoubleEntry::MonthRange.from_time(given_time) }
+    subject(:from_time) { MonthRange.from_time(given_time) }
 
     context "given the Time 31st March 2012" do
       let(:given_time) { Time.new(2012, 3, 31) }
@@ -19,15 +20,15 @@ describe DoubleEntry::MonthRange do
   end
 
   describe "::reportable_months" do
-    subject(:reportable_months) { DoubleEntry::MonthRange.reportable_months }
+    subject(:reportable_months) { MonthRange.reportable_months }
 
     context "The date is 1st March 1970" do
       before { Timecop.freeze(Time.new(1970, 3, 1)) }
 
       it { should eq [
-        DoubleEntry::MonthRange.new(year: 1970, month: 1),
-        DoubleEntry::MonthRange.new(year: 1970, month: 2),
-        DoubleEntry::MonthRange.new(year: 1970, month: 3),
+        MonthRange.new(year: 1970, month: 1),
+        MonthRange.new(year: 1970, month: 2),
+        MonthRange.new(year: 1970, month: 3),
       ] }
 
       context "My business started on 5th Feb 1970" do
@@ -38,8 +39,8 @@ describe DoubleEntry::MonthRange do
         end
 
         it { should eq [
-          DoubleEntry::MonthRange.new(year: 1970, month: 2),
-          DoubleEntry::MonthRange.new(year: 1970, month: 3),
+          MonthRange.new(year: 1970, month: 2),
+          MonthRange.new(year: 1970, month: 3),
         ] }
       end
     end
@@ -47,24 +48,24 @@ describe DoubleEntry::MonthRange do
     context "The date is 1st Jan 1970" do
       before { Timecop.freeze(Time.new(1970, 1, 1)) }
 
-      it { should eq [ DoubleEntry::MonthRange.new(year: 1970, month: 1) ] }
+      it { should eq [ MonthRange.new(year: 1970, month: 1) ] }
     end
   end
 
   describe "::beginning_of_financial_year" do
-    let(:month_range) { DoubleEntry::MonthRange.new(:year => year, :month => month) }
+    let(:month_range) { MonthRange.new(:year => year, :month => month) }
     let(:year) { 2014 }
 
     context "the first month of the financial year is July" do
       subject(:beginning_of_financial_year) { month_range.beginning_of_financial_year }
       context "returns the current year if the month is after July" do
         let(:month) { 10 }
-        it { should eq(DoubleEntry::MonthRange.new(:year => 2014, :month => 7)) }
+        it { should eq(MonthRange.new(:year => 2014, :month => 7)) }
       end
 
       context "returns the previous year if the month is before July" do
         let(:month) { 3 }
-        it { should eq(DoubleEntry::MonthRange.new(:year => 2013, :month => 7)) }
+        it { should eq(MonthRange.new(:year => 2013, :month => 7)) }
       end
     end
 
@@ -79,12 +80,12 @@ describe DoubleEntry::MonthRange do
 
       context "returns the current year if the month is after January" do
         let(:month) { 10 }
-        it { should eq(DoubleEntry::MonthRange.new(:year => 2014, :month => 1)) }
+        it { should eq(MonthRange.new(:year => 2014, :month => 1)) }
       end
 
       context "returns the current year if the month is January" do
         let(:month) { 1 }
-        it { should eq(DoubleEntry::MonthRange.new(:year => 2014, :month => 1)) }
+        it { should eq(MonthRange.new(:year => 2014, :month => 1)) }
       end
     end
 
@@ -99,33 +100,34 @@ describe DoubleEntry::MonthRange do
 
       context "returns the previous year if the month is before December (in the same year)" do
         let(:month) { 11 }
-        it { should eq(DoubleEntry::MonthRange.new(:year => 2013, :month => 12)) }
+        it { should eq(MonthRange.new(:year => 2013, :month => 12)) }
       end
 
       context "returns the previous year if the month is after December (in the next year)" do
         let(:year) { 2015 }
         let(:month) { 1 }
-        it { should eq(DoubleEntry::MonthRange.new(:year => 2014, :month => 12)) }
+        it { should eq(MonthRange.new(:year => 2014, :month => 12)) }
       end
 
       context "returns the current year if the month is December" do
         let(:month) { 12 }
-        it { should eq(DoubleEntry::MonthRange.new(:year => 2014, :month => 12)) }
+        it { should eq(MonthRange.new(:year => 2014, :month => 12)) }
       end
     end
 
     context "Given a start time of 3rd Dec 1982" do
-      subject(:reportable_months) { DoubleEntry::MonthRange.reportable_months(from: Time.new(1982, 12, 3)) }
+      subject(:reportable_months) { MonthRange.reportable_months(from: Time.new(1982, 12, 3)) }
 
       context "The date is 2nd Feb 1983" do
         before { Timecop.freeze(Time.new(1983, 2, 2)) }
 
         it { should eq [
-          DoubleEntry::MonthRange.new(year: 1982, month: 12),
-          DoubleEntry::MonthRange.new(year: 1983, month: 1),
-          DoubleEntry::MonthRange.new(year: 1983, month: 2),
+          MonthRange.new(year: 1982, month: 12),
+          MonthRange.new(year: 1983, month: 1),
+          MonthRange.new(year: 1983, month: 2),
         ] }
       end
     end
   end
+ end
 end