double_entry 1.0.1 → 2.0.0.beta1

data/spec/double_entry/reporting/line_aggregate_spec.rb

@@ -1,39 +0,0 @@
-# encoding: utf-8
-RSpec.describe DoubleEntry::Reporting::LineAggregate do
-  describe '.table_name' do
-    subject { DoubleEntry::Reporting::LineAggregate.table_name }
-    it { should eq('double_entry_line_aggregates') }
-  end
-
-  describe '#aggregate' do
-    let(:line_relation) { spy }
-    let(:filter) do
-      instance_double(DoubleEntry::Reporting::LineAggregateFilter, :filter => line_relation)
-    end
-
-    let(:function) { :sum }
-    let(:account) { spy }
-    let(:code) { spy }
-    let(:named_scopes) { spy }
-    let(:range) { spy }
-
-    subject(:aggregate) do
-      DoubleEntry::Reporting::LineAggregate.aggregate(function, account, code, range, named_scopes)
-    end
-
-    before do
-      allow(DoubleEntry::Reporting::LineAggregateFilter).to receive(:new).and_return(filter)
-      aggregate
-    end
-
-    it 'applies the specified filters' do
-      expect(DoubleEntry::Reporting::LineAggregateFilter).to have_received(:new).
-        with(account, code, range, named_scopes)
-      expect(filter).to have_received(:filter)
-    end
-
-    it 'performs the aggregation on the filtered lines' do
-      expect(line_relation).to have_received(:sum).with(:amount)
-    end
-  end
-end

data/spec/double_entry/reporting/month_range_spec.rb

@@ -1,139 +0,0 @@
-# encoding: utf-8
-module DoubleEntry
-  module Reporting
-    RSpec.describe MonthRange do
-      describe '.from_time' do
-        subject(:from_time) { MonthRange.from_time(given_time) }
-
-        context 'given the Time 31st March 2012' do
-          let(:given_time) { Time.new(2012, 3, 31) }
-          its(:year) { should eq 2012 }
-          its(:month) { should eq 3 }
-        end
-
-        context 'given the Date 31st March 2012' do
-          let(:given_time) { Date.parse('2012-03-31') }
-          its(:year) { should eq 2012 }
-          its(:month) { should eq 3 }
-        end
-      end
-
-      describe '.reportable_months' do
-        subject(:reportable_months) { MonthRange.reportable_months }
-
-        context 'The date is 1st March 1970' do
-          before { Timecop.freeze(Time.new(1970, 3, 1)) }
-
-          specify do
-            should eq [
-              MonthRange.new(:year => 1970, :month => 1),
-              MonthRange.new(:year => 1970, :month => 2),
-              MonthRange.new(:year => 1970, :month => 3),
-            ]
-          end
-
-          context 'My business started on 5th Feb 1970' do
-            before do
-              DoubleEntry::Reporting.configure do |config|
-                config.start_of_business = Time.new(1970, 2, 5)
-              end
-            end
-
-            specify do
-              should eq [
-                MonthRange.new(:year => 1970, :month => 2),
-                MonthRange.new(:year => 1970, :month => 3),
-              ]
-            end
-          end
-        end
-
-        context 'The date is 1st Jan 1970' do
-          before { Timecop.freeze(Time.new(1970, 1, 1)) }
-
-          it { should eq [MonthRange.new(:year => 1970, :month => 1)] }
-        end
-      end
-
-      describe '.beginning_of_financial_year' do
-        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(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(MonthRange.new(:year => 2013, :month => 7)) }
-          end
-        end
-
-        context 'the first month of the financial year is January' do
-          subject(:beginning_of_financial_year) { month_range.beginning_of_financial_year }
-
-          before do
-            DoubleEntry::Reporting.configure do |config|
-              config.first_month_of_financial_year = 1
-            end
-          end
-
-          context 'returns the current year if the month is after January' do
-            let(:month) { 10 }
-            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(MonthRange.new(:year => 2014, :month => 1)) }
-          end
-        end
-
-        context 'the first month of the financial year is December' do
-          subject(:beginning_of_financial_year) { month_range.beginning_of_financial_year }
-
-          before do
-            DoubleEntry::Reporting.configure do |config|
-              config.first_month_of_financial_year = 12
-            end
-          end
-
-          context 'returns the previous year if the month is before December (in the same year)' do
-            let(:month) { 11 }
-            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(MonthRange.new(:year => 2014, :month => 12)) }
-          end
-
-          context 'returns the current year if the month is December' do
-            let(: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) { 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)) }
-
-            specify do
-              should eq [
-                MonthRange.new(:year => 1982, :month => 12),
-                MonthRange.new(:year => 1983, :month => 1),
-                MonthRange.new(:year => 1983, :month => 2),
-              ]
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/double_entry/reporting/time_range_array_spec.rb

@@ -1,169 +0,0 @@
-module DoubleEntry
-  module Reporting
-    RSpec.describe TimeRangeArray do
-      describe '.make' do
-        subject(:time_range_array) { TimeRangeArray.make(range_type, start, finish) }
-
-        context 'for "hour" range type' do
-          let(:range_type) { 'hour' }
-
-          context 'given start is "2007-05-03 15:00:00" and finish is "2007-05-03 18:00:00"' do
-            let(:start)  { '2007-05-03 15:00:00' }
-            let(:finish) { '2007-05-03 18:00:00' }
-            specify do
-              should eq [
-                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
-          end
-
-          context 'given start and finish are nil' do
-            it 'should raise an error' do
-              expect { TimeRangeArray.make(range_type, nil, nil) }.
-                to raise_error 'Must specify start of range'
-            end
-          end
-        end
-
-        context 'for "day" range type' do
-          let(:range_type) { 'day' }
-
-          context 'given start is "2007-05-03" and finish is "2007-05-07"' do
-            let(:start)  { '2007-05-03' }
-            let(:finish) { '2007-05-07' }
-            specify do
-              should eq [
-                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
-          end
-
-          context 'given start and finish are nil' do
-            it 'should raise an error' do
-              expect { TimeRangeArray.make(range_type, nil, nil) }.
-                to raise_error 'Must specify start of range'
-            end
-          end
-        end
-
-        context 'for "week" range type' do
-          let(:range_type) { 'week' }
-
-          context 'given start is "2007-05-03" and finish is "2007-05-24"' do
-            let(:start)  { '2007-05-03' }
-            let(:finish) { '2007-05-24' }
-            specify do
-              should eq [
-                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
-          end
-
-          context 'given start and finish are nil' do
-            it 'should raise an error' do
-              expect { TimeRangeArray.make(range_type, nil, nil) }.
-                to raise_error 'Must specify start of range'
-            end
-          end
-        end
-
-        context 'for "month" range type' do
-          let(:range_type) { 'month' }
-
-          context 'given start is "2007-05-03" and finish is "2007-08-24"' do
-            let(:start)  { '2007-05-03' }
-            let(:finish) { '2007-08-24' }
-            specify do
-              should eq [
-                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
-          end
-
-          context 'given finish is nil' do
-            let(:start)  { '2006-08-03' }
-            let(:finish) { nil }
-
-            context 'and the date is "2007-04-13"' do
-              before { Timecop.freeze(Time.new(2007, 4, 13)) }
-
-              specify do
-                should eq [
-                  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
-          end
-        end
-
-        context 'for "year" range type' do
-          let(:range_type) { 'year' }
-
-          context 'given the date is "2009-11-23"' do
-            before { Timecop.freeze(Time.new(2009, 11, 23)) }
-
-            context 'given start is "2007-05-03" and finish is "2008-08-24"' do
-              let(:start)  { '2007-05-03' }
-              let(:finish) { '2008-08-24' }
-
-              it 'takes notice of start and finish' do
-                should eq [
-                  YearRange.from_time(Time.new(2007)),
-                  YearRange.from_time(Time.new(2008)),
-                ]
-              end
-            end
-
-            context 'given the start of business is "2006-07-10"' do
-              before do
-                allow(DoubleEntry::Reporting).
-                  to receive_message_chain('configuration.start_of_business').
-                  and_return(Time.new(2006, 7, 10))
-              end
-
-              context 'given start and finish are nil' do
-                let(:start)  { nil }
-                let(:finish) { nil }
-                specify do
-                  should eq [
-                    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
-              end
-            end
-          end
-        end
-
-        context 'given an invalid range type "ueue"' do
-          it 'should raise an error' do
-            expect { TimeRangeArray.make('ueue') }.to raise_error ArgumentError
-          end
-        end
-      end
-    end
-  end
-end

data/spec/double_entry/reporting/time_range_spec.rb

@@ -1,45 +0,0 @@
-# encoding: utf-8
-module DoubleEntry
-  module Reporting
-    RSpec.describe TimeRange do
-      it 'should correctly calculate a month range' do
-        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 = TimeRange.make(:year => 2009, :month => 6).beginning_of_financial_year
-        expect(range.month).to eq 7
-        expect(range.year).to eq 2008
-        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(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(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(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(WeekRange.current.week).to eq 13
-        end
-      end
-    end
-  end
-end

data/spec/double_entry/reporting/week_range_spec.rb

@@ -1,103 +0,0 @@
-# encoding: utf-8
-module DoubleEntry
-  module Reporting
-    RSpec.describe WeekRange do
-      it 'should start week 1 of a year in the first week that has any day in the year' do
-        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 = 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
-
-      it 'handles daylight savings time properly' do
-        Time.use_zone('America/Los_Angeles') do
-          time = Time.zone.parse('Mon, 10 Mar 2014')
-          range = WeekRange.from_time time
-          expect(range.start.day).to eq 10
-        end
-      end
-
-      describe '::from_time' do
-        subject(:from_time) { WeekRange.from_time(given_time) }
-
-        context 'given the Time 31st March 2012' do
-          let(:given_time) { Time.new(2012, 3, 31) }
-          its(:year) { should eq 2012 }
-          its(:week) { should eq 14 }
-        end
-
-        context 'given the Date 31st March 2012' do
-          let(:given_time) { Date.parse('2012-03-31') }
-          its(:year) { should eq 2012 }
-          its(:week) { should eq 14 }
-        end
-      end
-
-      describe '::reportable_weeks' do
-        subject(:reportable_weeks) { WeekRange.reportable_weeks }
-
-        context 'The date is 1st Feb 1970' do
-          before { Timecop.freeze(Time.new(1970, 2, 1)) }
-
-          specify do
-            should eq [
-              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),
-            ]
-          end
-
-          context 'My business started on 25th Jan 1970' do
-            before do
-              DoubleEntry::Reporting.configure do |config|
-                config.start_of_business = Time.new(1970, 1, 25)
-              end
-            end
-
-            specify do
-              should eq [
-                WeekRange.new(:year => 1970, :week => 4),
-                WeekRange.new(:year => 1970, :week => 5),
-              ]
-            end
-          end
-        end
-
-        context 'The date is 1st Jan 1970' do
-          before { Timecop.freeze(Time.new(1970, 1, 1)) }
-
-          it { should eq [WeekRange.new(:year => 1970, :week => 1)] }
-        end
-
-        context 'Given a start time of 3rd Dec 1982' do
-          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)) }
-            specify do
-              should eq [
-                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
-  end
-end