double_entry 0.1.0 → 0.2.0

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

@@ -1,7 +1,8 @@
 require 'spec_helper'
-describe DoubleEntry::TimeRangeArray do
+module DoubleEntry::Reporting
+ describe TimeRangeArray do
   describe '.make' do
-    subject(:time_range_array) { DoubleEntry::TimeRangeArray.make(range_type, start, finish) }
+    subject(:time_range_array) { TimeRangeArray.make(range_type, start, finish) }
 
     context 'for "hour" range type' do
       let(:range_type) { 'hour' }
@@ -10,16 +11,16 @@ describe DoubleEntry::TimeRangeArray do
         let(:start)  { '2007-05-03 15:00:00' }
         let(:finish) { '2007-05-03 18:00:00' }
         it { should eq [
-          DoubleEntry::HourRange.from_time(Time.new(2007, 5, 3, 15)),
-          DoubleEntry::HourRange.from_time(Time.new(2007, 5, 3, 16)),
-          DoubleEntry::HourRange.from_time(Time.new(2007, 5, 3, 17)),
-          DoubleEntry::HourRange.from_time(Time.new(2007, 5, 3, 18)),
+          HourRange.from_time(Time.new(2007, 5, 3, 15)),
+          HourRange.from_time(Time.new(2007, 5, 3, 16)),
+          HourRange.from_time(Time.new(2007, 5, 3, 17)),
+          HourRange.from_time(Time.new(2007, 5, 3, 18)),
         ] }
       end
 
       context 'given start and finish are nil' do
         it 'should raise an error' do
-          expect { DoubleEntry::TimeRangeArray.make(range_type, nil, nil) }.
+          expect { TimeRangeArray.make(range_type, nil, nil) }.
             to raise_error 'Must specify range for hour-by-hour reports'
         end
       end
@@ -32,17 +33,17 @@ describe DoubleEntry::TimeRangeArray do
         let(:start)  { '2007-05-03' }
         let(:finish) { '2007-05-07' }
         it { should eq [
-          DoubleEntry::DayRange.from_time(Time.new(2007, 5, 3)),
-          DoubleEntry::DayRange.from_time(Time.new(2007, 5, 4)),
-          DoubleEntry::DayRange.from_time(Time.new(2007, 5, 5)),
-          DoubleEntry::DayRange.from_time(Time.new(2007, 5, 6)),
-          DoubleEntry::DayRange.from_time(Time.new(2007, 5, 7)),
+          DayRange.from_time(Time.new(2007, 5, 3)),
+          DayRange.from_time(Time.new(2007, 5, 4)),
+          DayRange.from_time(Time.new(2007, 5, 5)),
+          DayRange.from_time(Time.new(2007, 5, 6)),
+          DayRange.from_time(Time.new(2007, 5, 7)),
         ] }
       end
 
       context 'given start and finish are nil' do
         it 'should raise an error' do
-          expect { DoubleEntry::TimeRangeArray.make(range_type, nil, nil) }.
+          expect { TimeRangeArray.make(range_type, nil, nil) }.
             to raise_error 'Must specify range for day-by-day reports'
         end
       end
@@ -55,16 +56,16 @@ describe DoubleEntry::TimeRangeArray do
         let(:start)  { '2007-05-03' }
         let(:finish) { '2007-05-24' }
         it { should eq [
-          DoubleEntry::WeekRange.from_time(Time.new(2007, 5, 3)),
-          DoubleEntry::WeekRange.from_time(Time.new(2007, 5, 10)),
-          DoubleEntry::WeekRange.from_time(Time.new(2007, 5, 17)),
-          DoubleEntry::WeekRange.from_time(Time.new(2007, 5, 24)),
+          WeekRange.from_time(Time.new(2007, 5, 3)),
+          WeekRange.from_time(Time.new(2007, 5, 10)),
+          WeekRange.from_time(Time.new(2007, 5, 17)),
+          WeekRange.from_time(Time.new(2007, 5, 24)),
         ] }
       end
 
       context 'given start and finish are nil' do
         it 'should raise an error' do
-          expect { DoubleEntry::TimeRangeArray.make(range_type, nil, nil) }.
+          expect { TimeRangeArray.make(range_type, nil, nil) }.
             to raise_error 'Must specify range for week-by-week reports'
         end
       end
@@ -77,10 +78,10 @@ describe DoubleEntry::TimeRangeArray do
         let(:start)  { '2007-05-03' }
         let(:finish) { '2007-08-24' }
         it { should eq [
-          DoubleEntry::MonthRange.from_time(Time.new(2007, 5)),
-          DoubleEntry::MonthRange.from_time(Time.new(2007, 6)),
-          DoubleEntry::MonthRange.from_time(Time.new(2007, 7)),
-          DoubleEntry::MonthRange.from_time(Time.new(2007, 8)),
+          MonthRange.from_time(Time.new(2007, 5)),
+          MonthRange.from_time(Time.new(2007, 6)),
+          MonthRange.from_time(Time.new(2007, 7)),
+          MonthRange.from_time(Time.new(2007, 8)),
         ] }
       end
 
@@ -92,15 +93,15 @@ describe DoubleEntry::TimeRangeArray do
           before { Timecop.freeze(Time.new(2007, 4, 13)) }
 
           it { should eq [
-            DoubleEntry::MonthRange.from_time(Time.new(2006, 8)),
-            DoubleEntry::MonthRange.from_time(Time.new(2006, 9)),
-            DoubleEntry::MonthRange.from_time(Time.new(2006, 10)),
-            DoubleEntry::MonthRange.from_time(Time.new(2006, 11)),
-            DoubleEntry::MonthRange.from_time(Time.new(2006, 12)),
-            DoubleEntry::MonthRange.from_time(Time.new(2007, 1)),
-            DoubleEntry::MonthRange.from_time(Time.new(2007, 2)),
-            DoubleEntry::MonthRange.from_time(Time.new(2007, 3)),
-            DoubleEntry::MonthRange.from_time(Time.new(2007, 4)),
+            MonthRange.from_time(Time.new(2006, 8)),
+            MonthRange.from_time(Time.new(2006, 9)),
+            MonthRange.from_time(Time.new(2006, 10)),
+            MonthRange.from_time(Time.new(2006, 11)),
+            MonthRange.from_time(Time.new(2006, 12)),
+            MonthRange.from_time(Time.new(2007, 1)),
+            MonthRange.from_time(Time.new(2007, 2)),
+            MonthRange.from_time(Time.new(2007, 3)),
+            MonthRange.from_time(Time.new(2007, 4)),
           ] }
         end
       end
@@ -118,9 +119,9 @@ describe DoubleEntry::TimeRangeArray do
 
           it 'takes no notice of start and finish' do
             should eq [
-              DoubleEntry::YearRange.from_time(Time.new(2007)),
-              DoubleEntry::YearRange.from_time(Time.new(2008)),
-              DoubleEntry::YearRange.from_time(Time.new(2009)),
+              YearRange.from_time(Time.new(2007)),
+              YearRange.from_time(Time.new(2008)),
+              YearRange.from_time(Time.new(2009)),
             ]
           end
 
@@ -129,10 +130,10 @@ describe DoubleEntry::TimeRangeArray do
             let(:finish) { nil }
             it {
               should eq [
-                DoubleEntry::YearRange.from_time(Time.new(2006)),
-                DoubleEntry::YearRange.from_time(Time.new(2007)),
-                DoubleEntry::YearRange.from_time(Time.new(2008)),
-                DoubleEntry::YearRange.from_time(Time.new(2009)),
+                YearRange.from_time(Time.new(2006)),
+                YearRange.from_time(Time.new(2007)),
+                YearRange.from_time(Time.new(2008)),
+                YearRange.from_time(Time.new(2009)),
               ]
             }
           end
@@ -142,8 +143,9 @@ describe DoubleEntry::TimeRangeArray do
 
     context 'given an invalid range type "ueue"' do
       it 'should raise an error' do
-        expect { DoubleEntry::TimeRangeArray.make('ueue') }.to raise_error ArgumentError
+        expect { TimeRangeArray.make('ueue') }.to raise_error ArgumentError
       end
     end
   end
+ end
 end

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

@@ -1,43 +1,44 @@
 # encoding: utf-8
 require 'spec_helper'
-
-describe DoubleEntry::TimeRange do
+module DoubleEntry::Reporting
+ describe TimeRange do
   it 'should correctly calculate a month range' do
-    ar = DoubleEntry::TimeRange.make(:year => 2009, :month => 10)
+    ar = TimeRange.make(:year => 2009, :month => 10)
     expect(ar.start.to_s).to eq Time.mktime(2009, 10, 1, 0, 0, 0).to_s
     expect(ar.finish.to_s).to eq Time.mktime(2009, 10, 31, 23, 59, 59).to_s
   end
 
   it "should correctly calculate the beginning of the financial year" do
-    range = DoubleEntry::TimeRange.make(:year => 2009, :month => 6).beginning_of_financial_year
+    range = TimeRange.make(:year => 2009, :month => 6).beginning_of_financial_year
     expect(range.month).to eq 7
     expect(range.year).to eq 2008
-    range = DoubleEntry::TimeRange.make(:year => 2009, :month => 7).beginning_of_financial_year
+    range = TimeRange.make(:year => 2009, :month => 7).beginning_of_financial_year
     expect(range.month).to eq 7
     expect(range.year).to eq 2009
   end
 
   it "should correctly calculate the current week range for New Year's Day" do
     Timecop.freeze Time.mktime(2009, 1, 1) do
-      expect(DoubleEntry::WeekRange.current.week).to eq 1
+      expect(WeekRange.current.week).to eq 1
     end
   end
 
   it "should correctly calculate the current week range for the first Sunday in the year after New Years" do
     Timecop.freeze Time.mktime(2009, 1, 4) do
-      expect(DoubleEntry::WeekRange.current.week).to eq 1
+      expect(WeekRange.current.week).to eq 1
     end
   end
 
   it "should correctly calculate the current week range for the first Monday in the year after New Years" do
     Timecop.freeze Time.mktime(2009, 1, 5) do
-      expect(DoubleEntry::WeekRange.current.week).to eq 2
+      expect(WeekRange.current.week).to eq 2
     end
   end
 
   it "should correctly calculate the current week range for my birthday" do
     Timecop.freeze Time.mktime(2009, 3, 27) do
-      expect(DoubleEntry::WeekRange.current.week).to eq 13
+      expect(WeekRange.current.week).to eq 13
     end
   end
+ end
 end

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

@@ -1,22 +1,22 @@
 # encoding: utf-8
 require 'spec_helper'
-
-describe DoubleEntry::WeekRange do
+module DoubleEntry::Reporting
+describe WeekRange do
 
   it "should start week 1 of a year in the first week that has any day in the year" do
-    range = DoubleEntry::WeekRange.new(:year => 2011, :week => 1)
+    range = WeekRange.new(:year => 2011, :week => 1)
     expect(range.start).to eq Time.parse("2010-12-27 00:00:00")
   end
 
   it "should handle times in the last week of the year properly" do
-    range = DoubleEntry::WeekRange.from_time(Time.parse("2010-12-29 11:30:00"))
+    range = WeekRange.from_time(Time.parse("2010-12-29 11:30:00"))
     expect(range.year).to eq 2011
     expect(range.week).to eq 1
     expect(range.start).to eq Time.parse("2010-12-27 00:00:00")
   end
 
   describe "::from_time" do
-    subject(:from_time) { DoubleEntry::WeekRange.from_time(given_time) }
+    subject(:from_time) { WeekRange.from_time(given_time) }
 
     context "given the Time 31st March 2012" do
       let(:given_time) { Time.new(2012, 3, 31) }
@@ -32,17 +32,17 @@ describe DoubleEntry::WeekRange do
   end
 
   describe "::reportable_weeks" do
-    subject(:reportable_weeks) { DoubleEntry::WeekRange.reportable_weeks }
+    subject(:reportable_weeks) { WeekRange.reportable_weeks }
 
     context "The date is 1st Feb 1970" do
       before { Timecop.freeze(Time.new(1970, 2, 1)) }
 
       it { should eq [
-        DoubleEntry::WeekRange.new(year: 1970, week: 1),
-        DoubleEntry::WeekRange.new(year: 1970, week: 2),
-        DoubleEntry::WeekRange.new(year: 1970, week: 3),
-        DoubleEntry::WeekRange.new(year: 1970, week: 4),
-        DoubleEntry::WeekRange.new(year: 1970, week: 5),
+        WeekRange.new(year: 1970, week: 1),
+        WeekRange.new(year: 1970, week: 2),
+        WeekRange.new(year: 1970, week: 3),
+        WeekRange.new(year: 1970, week: 4),
+        WeekRange.new(year: 1970, week: 5),
       ] }
 
       context "My business started on 25th Jan 1970" do
@@ -53,8 +53,8 @@ describe DoubleEntry::WeekRange do
         end
 
         it { should eq [
-          DoubleEntry::WeekRange.new(year: 1970, week: 4),
-          DoubleEntry::WeekRange.new(year: 1970, week: 5),
+          WeekRange.new(year: 1970, week: 4),
+          WeekRange.new(year: 1970, week: 5),
         ] }
       end
     end
@@ -62,27 +62,28 @@ describe DoubleEntry::WeekRange do
     context "The date is 1st Jan 1970" do
       before { Timecop.freeze(Time.new(1970, 1, 1)) }
 
-      it { should eq [ DoubleEntry::WeekRange.new(year: 1970, week: 1) ] }
+      it { should eq [ WeekRange.new(year: 1970, week: 1) ] }
     end
 
     context "Given a start time of 3rd Dec 1982" do
-      subject(:reportable_weeks) { DoubleEntry::WeekRange.reportable_weeks(from: Time.new(1982, 12, 3)) }
+      subject(:reportable_weeks) { WeekRange.reportable_weeks(from: Time.new(1982, 12, 3)) }
 
       context "The date is 12nd Jan 1983" do
         before { Timecop.freeze(Time.new(1983, 2, 2)) }
         it { should eq [
-          DoubleEntry::WeekRange.new(year: 1982, week: 49),
-          DoubleEntry::WeekRange.new(year: 1982, week: 50),
-          DoubleEntry::WeekRange.new(year: 1982, week: 51),
-          DoubleEntry::WeekRange.new(year: 1982, week: 52),
-          DoubleEntry::WeekRange.new(year: 1983, week: 1),
-          DoubleEntry::WeekRange.new(year: 1983, week: 2),
-          DoubleEntry::WeekRange.new(year: 1983, week: 3),
-          DoubleEntry::WeekRange.new(year: 1983, week: 4),
-          DoubleEntry::WeekRange.new(year: 1983, week: 5),
-          DoubleEntry::WeekRange.new(year: 1983, week: 6),
+          WeekRange.new(year: 1982, week: 49),
+          WeekRange.new(year: 1982, week: 50),
+          WeekRange.new(year: 1982, week: 51),
+          WeekRange.new(year: 1982, week: 52),
+          WeekRange.new(year: 1983, week: 1),
+          WeekRange.new(year: 1983, week: 2),
+          WeekRange.new(year: 1983, week: 3),
+          WeekRange.new(year: 1983, week: 4),
+          WeekRange.new(year: 1983, week: 5),
+          WeekRange.new(year: 1983, week: 6),
         ] }
       end
     end
   end
+ end
 end

data/spec/double_entry/reporting_spec.rb

@@ -22,4 +22,28 @@ describe DoubleEntry::Reporting do
     end
   end
 
+  describe "::scopes_with_minimum_balance_for_account" do
+    subject(:scopes) { DoubleEntry::Reporting.scopes_with_minimum_balance_for_account(minimum_balance, :checking) }
+
+    context "a 'checking' account with balance $100" do
+      let!(:user) { User.make!(:checking_balance => Money.new(100_00)) }
+
+      context "when searching for balance $99" do
+        let(:minimum_balance) { Money.new(99_00) }
+        it { should include user.id }
+      end
+
+      context "when searching for balance $100" do
+        let(:minimum_balance) { Money.new(100_00) }
+        it { should include user.id }
+      end
+
+      context "when searching for balance $101" do
+        let(:minimum_balance) { Money.new(101_00) }
+        it { should_not include user.id }
+      end
+    end
+  end
+
+
 end

data/spec/double_entry/transfer_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+require 'spec_helper'
+describe DoubleEntry::Transfer::Set do
+  describe "#define" do
+    before do
+      subject.define(
+        :code => "code",
+        :from => double(:identifier => "from"),
+        :to => double(:identifier => "to"),
+      )
+    end
+    its(:first) { should be_a DoubleEntry::Transfer }
+    its("first.code") { should eq "code" }
+    its("first.from.identifier") { should eq "from" }
+    its("first.to.identifier") { should eq "to" }
+  end
+end

data/spec/double_entry/{line_check_spec.rb → validation/line_check_spec.rb}

@@ -1,32 +1,32 @@
 # encoding: utf-8
 require 'spec_helper'
-
-describe DoubleEntry::LineCheck do
+module DoubleEntry::Validation
+ describe LineCheck do
 
   describe '#last' do
 
     context 'Given some checks have been created' do
       before do
         Timecop.freeze 3.minutes.ago do
-          DoubleEntry::LineCheck.create! :last_line_id => 100, :errors_found => false, :log => ''
+          LineCheck.create! :last_line_id => 100, :errors_found => false, :log => ''
         end
         Timecop.freeze 1.minute.ago do
-          DoubleEntry::LineCheck.create! :last_line_id => 300, :errors_found => false, :log => ''
+          LineCheck.create! :last_line_id => 300, :errors_found => false, :log => ''
         end
         Timecop.freeze 2.minutes.ago do
-          DoubleEntry::LineCheck.create! :last_line_id => 200, :errors_found => false, :log => ''
+          LineCheck.create! :last_line_id => 200, :errors_found => false, :log => ''
         end
       end
 
       it 'should find the newest LineCheck created (by creation_date)' do
-        expect(DoubleEntry::LineCheck.last.last_line_id).to eq 300
+        expect(LineCheck.last.last_line_id).to eq 300
       end
     end
 
   end
 
   describe '#perform!' do
-    subject(:performed_line_check) { DoubleEntry::LineCheck.perform! }
+    subject(:performed_line_check) { LineCheck.perform! }
 
     context 'Given a user with 100 dollars' do
       before { User.make!(:savings_balance => Money.new(100_00)) }
@@ -34,23 +34,23 @@ describe DoubleEntry::LineCheck do
       context 'And all is consistent' do
 
         context 'And all lines have been checked' do
-          before { DoubleEntry::LineCheck.perform!  }
+          before { LineCheck.perform!  }
 
           it { should be_nil }
 
           it 'should not persist a new LineCheck' do
             expect {
-              DoubleEntry::LineCheck.perform!
-            }.to_not change { DoubleEntry::LineCheck.count }
+              LineCheck.perform!
+            }.to_not change { LineCheck.count }
           end
         end
 
-        it { should be_instance_of DoubleEntry::LineCheck }
+        it { should be_instance_of LineCheck }
         its(:errors_found) { should eq false }
 
         it 'should persist the LineCheck' do
-          line_check = DoubleEntry::LineCheck.perform!
-          expect(DoubleEntry::LineCheck.last).to eq line_check
+          line_check = LineCheck.perform!
+          expect(LineCheck.last).to eq line_check
         end
       end
 
@@ -62,7 +62,7 @@ describe DoubleEntry::LineCheck do
 
         it 'should correct the running balance' do
           expect {
-            DoubleEntry::LineCheck.perform!
+            LineCheck.perform!
           }.to change { DoubleEntry::Line.order(:id).first.balance }.by Money.new(-1)
         end
       end
@@ -74,15 +74,16 @@ describe DoubleEntry::LineCheck do
 
         it 'should correct the account balance' do
           expect {
-            DoubleEntry::LineCheck.perform!
+            LineCheck.perform!
           }.to change { DoubleEntry::AccountBalance.order(:id).first.balance }.by Money.new(-1)
         end
       end
     end
 
     it "has a table name prefixed with double_entry_" do
-      expect(DoubleEntry::LineCheck.table_name).to eq "double_entry_line_checks"
+      expect(LineCheck.table_name).to eq "double_entry_line_checks"
     end
 
   end
+ end
 end