double_entry 0.10.0 → 0.10.1

data/spec/double_entry/reporting/line_aggregate_spec.rb

@@ -1,10 +1,11 @@
 # 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"
+module DoubleEntry
+  module Reporting
+    RSpec.describe LineAggregate do
+      describe '.table_name' do
+        subject { LineAggregate.table_name }
+        it { should eq('double_entry_line_aggregates') }
+      end
     end
   end
 end

data/spec/double_entry/reporting/month_range_spec.rb

@@ -1,133 +1,139 @@
 # encoding: utf-8
-require "spec_helper"
-module DoubleEntry::Reporting
-  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
+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
+        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 }
+      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)) }
+        context 'The date is 1st March 1970' do
+          before { Timecop.freeze(Time.new(1970, 3, 1)) }
 
-      it { should eq [
-        MonthRange.new(year: 1970, month: 1),
-        MonthRange.new(year: 1970, month: 2),
-        MonthRange.new(year: 1970, month: 3),
-      ] }
+          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)
+          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
 
-        it { should eq [
-          MonthRange.new(year: 1970, month: 2),
-          MonthRange.new(year: 1970, month: 3),
-        ] }
-      end
-    end
+        context 'The date is 1st Jan 1970' do
+          before { Timecop.freeze(Time.new(1970, 1, 1)) }
 
-    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)) }
+          it { should eq [MonthRange.new(:year => 1970, :month => 1)] }
+        end
       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
+      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 January" do
-      subject(:beginning_of_financial_year) { month_range.beginning_of_financial_year }
+        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
 
-      before do
-        DoubleEntry::Reporting.configure do |config|
-          config.first_month_of_financial_year = 1
+          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
-      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 'the first month of the financial year is January' do
+          subject(:beginning_of_financial_year) { month_range.beginning_of_financial_year }
 
-      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
+          before do
+            DoubleEntry::Reporting.configure do |config|
+              config.first_month_of_financial_year = 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 }
+          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
 
-      before do
-        DoubleEntry::Reporting.configure do |config|
-          config.first_month_of_financial_year = 12
+          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
-      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 'the first month of the financial year is December' do
+          subject(:beginning_of_financial_year) { month_range.beginning_of_financial_year }
 
-      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
+          before do
+            DoubleEntry::Reporting.configure do |config|
+              config.first_month_of_financial_year = 12
+            end
+          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 '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 "Given a start time of 3rd Dec 1982" do
-      subject(:reportable_months) { MonthRange.reportable_months(from: Time.new(1982, 12, 3)) }
+          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)) }
+          context 'The date is 2nd Feb 1983' do
+            before { Timecop.freeze(Time.new(1983, 2, 2)) }
 
-        it { should eq [
-          MonthRange.new(year: 1982, month: 12),
-          MonthRange.new(year: 1983, month: 1),
-          MonthRange.new(year: 1983, month: 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
 end

data/spec/double_entry/reporting/time_range_array_spec.rb

@@ -1,159 +1,169 @@
-require 'spec_helper'
-module DoubleEntry::Reporting
- 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' }
-        it { 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
+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'
+          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
-      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' }
-        it { 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
-
-      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 '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' }
-        it { 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
+          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'
+          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
-      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' }
-        it { 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
+        context 'for "week" range type' do
+          let(:range_type) { 'week' }
 
-      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)) }
-
-          it { 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
+          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 'for "year" range type' do
-      let(:range_type) { 'year' }
+          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 'given the date is "2009-11-23"' do
-        before { Timecop.freeze(Time.new(2009, 11, 23)) }
+        context 'for "month" range type' do
+          let(:range_type) { 'month' }
 
-        context 'given start is "2007-05-03" and finish is "2008-08-24"' do
-          let(:start)  { '2007-05-03' }
-          let(:finish) { '2008-08-24' }
+          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 }
 
-          it 'takes notice of start and finish' do
-            should eq [
-              YearRange.from_time(Time.new(2007)),
-              YearRange.from_time(Time.new(2008)),
-            ]
+            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 '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))
+        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 start and finish are nil' do
-            let(:start)  { nil }
-            let(:finish) { nil }
-            it {
-              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)),
-              ]
-            }
+        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
-
-    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