by_star 4.0.0 → 4.0.1

data/spec/integration/shared/between_times.rb

@@ -1,99 +1,99 @@
-require 'spec_helper'
-
-shared_examples_for 'between_times' do
-
-  describe '#between_times' do
-    subject { Post.between_times(Time.zone.parse('2014-01-01'), Time.zone.parse('2014-01-06')) }
-
-    if testing_active_record?
-      it { is_expected.to be_a(ActiveRecord::Relation) }
-    else testing_mongoid?
-      it { is_expected.to be_a(Mongoid::Criteria) }
-    end
-
-    it { expect(subject.count).to eql(3) }
-
-    context 'one-sided query' do
-
-      context 'point query' do
-
-        context 'only start time' do
-          subject { Post.between_times(Time.zone.parse('2014-01-01'), nil) }
-          it { expect(subject.count).to eql(12) }
-        end
-
-        context 'only end time' do
-          subject { Post.between_times(nil, Time.zone.parse('2014-01-01')) }
-          it { expect(subject.count).to eql(10) }
-
-          context 'neither start nor end time' do
-            subject { Post.between_times(nil, nil) }
-            it { expect(subject.count).to eql(22) }
-          end
-        end
-      end
-
-      context 'timespan loose query' do
-
-        context 'only start time' do
-          subject { Event.between_times(Time.zone.parse('2014-01-01'), nil, strict: false) }
-          it { expect(subject.count).to eql(17) }
-        end
-
-        context 'only end time' do
-          subject { Event.between_times(nil, Time.zone.parse('2014-01-01'), strict: false) }
-          it { expect(subject.count).to eql(13) }
-
-          context 'neither start nor end time' do
-            subject { Event.between_times(nil, nil) }
-            it { expect(subject.count).to eql(30) }
-          end
-        end
-      end
-
-      context 'timespan strict query' do
-
-        context 'only start time' do
-          subject { Event.between_times(Time.zone.parse('2014-01-01'), nil) }
-          it { expect(subject.count).to eql(17) }
-        end
-
-        context 'only end time' do
-          subject { Event.between_times(nil, Time.zone.parse('2014-01-01')) }
-          it { expect(subject.count).to eql(13) }
-
-          context 'neither start nor end time' do
-            subject { Event.between_times(nil, nil) }
-            it { expect(subject.count).to eql(30) }
-          end
-        end
-      end
-    end
-
-    context 'two-sided query' do
-      context 'DST starts (Sydney)', sydney: true do
-        context 'day before' do
-          subject { Event.between_times(Date.parse('2020-04-04'), Date.parse('2020-04-04'), offset: 5.hours) }
-          it { expect(subject.count).to eql(3) }
-        end
-
-        context 'same day' do
-          subject { Event.between_times(Date.parse('2020-04-05'), Date.parse('2020-04-05'), offset: 5.hours) }
-          it { expect(subject.count).to eql(1) }
-        end
-      end
-
-      context 'when DST ends (Sydney)', sydney: true do
-        context 'day before' do
-          subject { Event.between_times(Date.parse('2020-10-03'), Date.parse('2020-10-03'), offset: 5.hours) }
-          it { expect(subject.count).to eql(1) }
-        end
-
-        context 'same day' do
-          subject { Event.between_times(Date.parse('2020-10-04'), Date.parse('2020-10-04'), offset: 5.hours) }
-          it { expect(subject.count).to eql(3) }
-        end
-      end
-    end
-  end
-end
+require 'spec_helper'
+
+shared_examples_for 'between_times' do
+
+  describe '#between_times' do
+    subject { Post.between_times(Time.zone.parse('2014-01-01'), Time.zone.parse('2014-01-06')) }
+
+    if testing_active_record?
+      it { is_expected.to be_a(ActiveRecord::Relation) }
+    else testing_mongoid?
+      it { is_expected.to be_a(Mongoid::Criteria) }
+    end
+
+    it { expect(subject.count).to eql(3) }
+
+    context 'one-sided query' do
+
+      context 'point query' do
+
+        context 'only start time' do
+          subject { Post.between_times(Time.zone.parse('2014-01-01'), nil) }
+          it { expect(subject.count).to eql(12) }
+        end
+
+        context 'only end time' do
+          subject { Post.between_times(nil, Time.zone.parse('2014-01-01')) }
+          it { expect(subject.count).to eql(10) }
+
+          context 'neither start nor end time' do
+            subject { Post.between_times(nil, nil) }
+            it { expect(subject.count).to eql(22) }
+          end
+        end
+      end
+
+      context 'timespan loose query' do
+
+        context 'only start time' do
+          subject { Event.between_times(Time.zone.parse('2014-01-01'), nil, strict: false) }
+          it { expect(subject.count).to eql(17) }
+        end
+
+        context 'only end time' do
+          subject { Event.between_times(nil, Time.zone.parse('2014-01-01'), strict: false) }
+          it { expect(subject.count).to eql(13) }
+
+          context 'neither start nor end time' do
+            subject { Event.between_times(nil, nil) }
+            it { expect(subject.count).to eql(30) }
+          end
+        end
+      end
+
+      context 'timespan strict query' do
+
+        context 'only start time' do
+          subject { Event.between_times(Time.zone.parse('2014-01-01'), nil) }
+          it { expect(subject.count).to eql(17) }
+        end
+
+        context 'only end time' do
+          subject { Event.between_times(nil, Time.zone.parse('2014-01-01')) }
+          it { expect(subject.count).to eql(13) }
+
+          context 'neither start nor end time' do
+            subject { Event.between_times(nil, nil) }
+            it { expect(subject.count).to eql(30) }
+          end
+        end
+      end
+    end
+
+    context 'two-sided query' do
+      context 'DST starts (Sydney)', sydney: true do
+        context 'day before' do
+          subject { Event.between_times(Date.parse('2020-04-04'), Date.parse('2020-04-04'), offset: 5.hours) }
+          it { expect(subject.count).to eql(3) }
+        end
+
+        context 'same day' do
+          subject { Event.between_times(Date.parse('2020-04-05'), Date.parse('2020-04-05'), offset: 5.hours) }
+          it { expect(subject.count).to eql(1) }
+        end
+      end
+
+      context 'when DST ends (Sydney)', sydney: true do
+        context 'day before' do
+          subject { Event.between_times(Date.parse('2020-10-03'), Date.parse('2020-10-03'), offset: 5.hours) }
+          it { expect(subject.count).to eql(1) }
+        end
+
+        context 'same day' do
+          subject { Event.between_times(Date.parse('2020-10-04'), Date.parse('2020-10-04'), offset: 5.hours) }
+          it { expect(subject.count).to eql(3) }
+        end
+      end
+    end
+  end
+end

data/spec/integration/shared/by_calendar_month.rb

@@ -1,55 +1,55 @@
-require 'spec_helper'
-
-shared_examples_for 'by calendar month' do
-
-  describe '#by_calendar_month' do
-
-    context 'point-in-time' do
-      subject { Post.by_calendar_month('Feb') }
-      it { expect(subject.count).to eql(3) }
-    end
-
-    context 'timespan' do
-      subject { Event.by_calendar_month(1) }
-      it { expect(subject.count).to eql(10) }
-    end
-
-    context 'timespan strict' do
-      subject { Event.by_calendar_month(Date.parse('2014-02-01'), strict: true) }
-      it { expect(subject.count).to eql(2) }
-    end
-
-    context 'with :year option' do
-
-      context 'point-in-time' do
-        subject { Post.by_calendar_month(12, year: 2013) }
-        it { expect(subject.count).to eql(12) }
-      end
-
-      context 'timespan' do
-        subject { Event.by_calendar_month('December', year: 2013) }
-        it { expect(subject.count).to eql(13) }
-      end
-
-      context 'timespan strict' do
-        subject { Event.by_calendar_month('Dec', year: 2013, strict: true) }
-        it { expect(subject.count).to eql(9) }
-      end
-    end
-
-    it 'should raise an error when given an invalid argument' do
-      expect{ Post.by_calendar_month(0) }.to raise_error(ByStar::ParseError, 'Month must be a number between 1 and 12 or a month name')
-      expect{ Post.by_calendar_month(13) }.to raise_error(ByStar::ParseError, 'Month must be a number between 1 and 12 or a month name')
-      expect{ Post.by_calendar_month('foobar') }.to raise_error(ByStar::ParseError, 'Month must be a number between 1 and 12 or a month name')
-    end
-
-    it 'should be able to use an alternative field' do
-      expect(Event.by_calendar_month(field: 'end_time').count).to eql(9)
-    end
-
-    context ':start_day option' do
-      subject { Post.by_calendar_month(1, start_day: :wednesday) }
-      it{ expect(subject.count).to eql(7) }
-    end
-  end
-end
+require 'spec_helper'
+
+shared_examples_for 'by calendar month' do
+
+  describe '#by_calendar_month' do
+
+    context 'point-in-time' do
+      subject { Post.by_calendar_month('Feb') }
+      it { expect(subject.count).to eql(3) }
+    end
+
+    context 'timespan' do
+      subject { Event.by_calendar_month(1) }
+      it { expect(subject.count).to eql(10) }
+    end
+
+    context 'timespan strict' do
+      subject { Event.by_calendar_month(Date.parse('2014-02-01'), strict: true) }
+      it { expect(subject.count).to eql(2) }
+    end
+
+    context 'with :year option' do
+
+      context 'point-in-time' do
+        subject { Post.by_calendar_month(12, year: 2013) }
+        it { expect(subject.count).to eql(12) }
+      end
+
+      context 'timespan' do
+        subject { Event.by_calendar_month('December', year: 2013) }
+        it { expect(subject.count).to eql(13) }
+      end
+
+      context 'timespan strict' do
+        subject { Event.by_calendar_month('Dec', year: 2013, strict: true) }
+        it { expect(subject.count).to eql(9) }
+      end
+    end
+
+    it 'should raise an error when given an invalid argument' do
+      expect{ Post.by_calendar_month(0) }.to raise_error(ByStar::ParseError, 'Month must be a number between 1 and 12 or a month name')
+      expect{ Post.by_calendar_month(13) }.to raise_error(ByStar::ParseError, 'Month must be a number between 1 and 12 or a month name')
+      expect{ Post.by_calendar_month('foobar') }.to raise_error(ByStar::ParseError, 'Month must be a number between 1 and 12 or a month name')
+    end
+
+    it 'should be able to use an alternative field' do
+      expect(Event.by_calendar_month(field: 'end_time').count).to eql(9)
+    end
+
+    context ':start_day option' do
+      subject { Post.by_calendar_month(1, start_day: :wednesday) }
+      it{ expect(subject.count).to eql(7) }
+    end
+  end
+end

data/spec/integration/shared/by_cweek.rb

@@ -1,54 +1,54 @@
-require 'spec_helper'
-
-shared_examples_for 'by cweek' do
-
-  describe '#by_cweek' do
-
-    context 'point-in-time' do
-      subject { Post.by_cweek('2014-01-02') }
-      it { expect(subject.count).to eql(4) }
-    end
-
-    context 'timespan' do
-      subject { Event.by_cweek(1) }
-      it { expect(subject.count).to eql(7) }
-    end
-
-    context 'timespan strict' do
-      subject { Event.by_cweek(Date.parse('2014-01-01'), strict: true) }
-      it { expect(subject.count).to eql(0) }
-    end
-
-    context 'with :year option' do
-
-      context 'point-in-time' do
-        subject { Post.by_cweek(53, year: 2013) }
-        it { expect(subject.count).to eql(4) }
-      end
-
-      context 'timespan' do
-        subject { Event.by_cweek(53, year: 2013) }
-        it { expect(subject.count).to eql(7) }
-      end
-
-      context 'timespan strict' do
-        subject { Event.by_cweek(53, year: 2013, strict: true) }
-        it { expect(subject.count).to eql(0) }
-      end
-    end
-
-    it 'should raise an error when given an invalid argument' do
-      expect { Post.by_cweek(0) }.to raise_error(ByStar::ParseError, 'cweek number must be between 1 and 53')
-      expect { Post.by_cweek(54) }.to raise_error(ByStar::ParseError, 'cweek number must be between 1 and 53')
-    end
-
-    it 'should be able to use an alternative field' do
-      expect(Event.by_cweek(field: 'end_time').count).to eq 3
-    end
-
-    context ':start_day option' do
-      subject { Post.by_cweek('2014-01-02', start_day: :thursday) }
-      it { expect(subject.count).to eql(1) }
-    end
-  end
-end
+require 'spec_helper'
+
+shared_examples_for 'by cweek' do
+
+  describe '#by_cweek' do
+
+    context 'point-in-time' do
+      subject { Post.by_cweek('2014-01-02') }
+      it { expect(subject.count).to eql(4) }
+    end
+
+    context 'timespan' do
+      subject { Event.by_cweek(1) }
+      it { expect(subject.count).to eql(7) }
+    end
+
+    context 'timespan strict' do
+      subject { Event.by_cweek(Date.parse('2014-01-01'), strict: true) }
+      it { expect(subject.count).to eql(0) }
+    end
+
+    context 'with :year option' do
+
+      context 'point-in-time' do
+        subject { Post.by_cweek(53, year: 2013) }
+        it { expect(subject.count).to eql(4) }
+      end
+
+      context 'timespan' do
+        subject { Event.by_cweek(53, year: 2013) }
+        it { expect(subject.count).to eql(7) }
+      end
+
+      context 'timespan strict' do
+        subject { Event.by_cweek(53, year: 2013, strict: true) }
+        it { expect(subject.count).to eql(0) }
+      end
+    end
+
+    it 'should raise an error when given an invalid argument' do
+      expect { Post.by_cweek(0) }.to raise_error(ByStar::ParseError, 'cweek number must be between 1 and 53')
+      expect { Post.by_cweek(54) }.to raise_error(ByStar::ParseError, 'cweek number must be between 1 and 53')
+    end
+
+    it 'should be able to use an alternative field' do
+      expect(Event.by_cweek(field: 'end_time').count).to eq 3
+    end
+
+    context ':start_day option' do
+      subject { Post.by_cweek('2014-01-02', start_day: :thursday) }
+      it { expect(subject.count).to eql(1) }
+    end
+  end
+end

data/spec/integration/shared/by_day.rb

@@ -1,120 +1,120 @@
-require 'spec_helper'
-
-shared_examples_for 'by day' do
-
-  describe '#by_day' do
-
-    context 'point-in-time' do
-      it { expect(Post.by_day('2014-01-01').count).to eql(2) }
-    end
-
-    context 'timespan' do
-      it { expect(Event.by_day(Time.zone.parse '2014-01-01').count).to eql(5) }
-    end
-
-    context 'timespan strict' do
-      it { expect(Event.by_day(Date.parse('2014-01-01'), strict: true).count).to eql(0) }
-    end
-
-    it 'should be able to use an alternative field' do
-      expect(Event.by_day(field: 'end_time').count).to eql(0)
-    end
-
-    it 'should support :offset option' do
-      expect(Post.by_day('2014-01-01', offset: -16.hours).count).to eq(1)
-    end
-
-    context 'when DST starts (Sydney)', sydney: true do
-      context 'day before' do
-        subject { Event.by_day('2020-04-04', offset: 5.hours) }
-        it { expect(subject.count).to eq(3) }
-      end
-
-      context 'same day' do
-        subject { Event.by_day('2020-04-05', offset: 5.hours) }
-        it { expect(subject.count).to eq(1) }
-      end
-    end
-
-    context 'when DST ends (Sydney)', sydney: true do
-      context 'day before' do
-        subject { Event.by_day('2020-10-03', offset: 5.hours) }
-        it { expect(subject.count).to eq(1) }
-      end
-
-      context 'same day' do
-        subject { Event.by_day('2020-10-04', offset: 5.hours) }
-        it { expect(subject.count).to eq(3) }
-      end
-    end
-  end
-
-  describe '#today' do # 2014-01-01
-
-    context 'point-in-time' do
-      it { expect(Post.today.count).to eql(2) }
-    end
-
-    context 'timespan' do
-      it { expect(Event.today.count).to eql(5) }
-    end
-
-    context 'timespan strict' do
-      it { expect(Event.today(strict: true).count).to eql(0) }
-    end
-
-    it 'should be able to use an alternative field' do
-      expect(Event.today(field: 'created_at').count).to eql(2)
-    end
-
-    it 'should support :offset option' do
-      expect(Post.today(offset: -24.hours).count).to eql(1)
-    end
-  end
-
-  describe '#yesterday' do # 2013-12-31
-
-    context 'point-in-time' do
-      it { expect(Post.yesterday.count).to eql(1) }
-    end
-
-    context 'timespan' do
-      it { expect(Event.yesterday.count).to eql(5) }
-    end
-
-    context 'timespan strict' do
-      it { expect(Event.yesterday(strict: true).count).to eql(0) }
-    end
-
-    it 'should be able to use an alternative field' do
-      expect(Event.yesterday(field: 'created_at').count).to eql(1)
-    end
-
-    it 'should support :offset option' do
-      expect(Post.yesterday(offset: 24.hours).count).to eql(2)
-    end
-  end
-
-  describe '#tomorrow' do # 2014-01-02
-
-    context 'point-in-time' do
-      it { expect(Post.tomorrow.count).to eql(0) }
-    end
-
-    context 'timespan' do
-      it { expect(Event.tomorrow.count).to eql(5) }
-    end
-
-    context 'timespan strict' do
-      it { expect(Event.tomorrow(strict: true).count).to eql(0) }
-    end
-
-    it 'should be able to use an alternative field' do
-      expect(Event.tomorrow(field: 'created_at').count).to eql(0)
-    end
-
-    it 'should support :offset option' do
-      expect(Post.tomorrow(offset: -24.hours).count).to eql(2)
-    end
-  end
-end
+require 'spec_helper'
+
+shared_examples_for 'by day' do
+
+  describe '#by_day' do
+
+    context 'point-in-time' do
+      it { expect(Post.by_day('2014-01-01').count).to eql(2) }
+    end
+
+    context 'timespan' do
+      it { expect(Event.by_day(Time.zone.parse '2014-01-01').count).to eql(5) }
+    end
+
+    context 'timespan strict' do
+      it { expect(Event.by_day(Date.parse('2014-01-01'), strict: true).count).to eql(0) }
+    end
+
+    it 'should be able to use an alternative field' do
+      expect(Event.by_day(field: 'end_time').count).to eql(0)
+    end
+
+    it 'should support :offset option' do
+      expect(Post.by_day('2014-01-01', offset: -16.hours).count).to eq(1)
+    end
+
+    context 'when DST starts (Sydney)', sydney: true do
+      context 'day before' do
+        subject { Event.by_day('2020-04-04', offset: 5.hours) }
+        it { expect(subject.count).to eq(3) }
+      end
+
+      context 'same day' do
+        subject { Event.by_day('2020-04-05', offset: 5.hours) }
+        it { expect(subject.count).to eq(1) }
+      end
+    end
+
+    context 'when DST ends (Sydney)', sydney: true do
+      context 'day before' do
+        subject { Event.by_day('2020-10-03', offset: 5.hours) }
+        it { expect(subject.count).to eq(1) }
+      end
+
+      context 'same day' do
+        subject { Event.by_day('2020-10-04', offset: 5.hours) }
+        it { expect(subject.count).to eq(3) }
+      end
+    end
+  end
+
+  describe '#today' do # 2014-01-01
+
+    context 'point-in-time' do
+      it { expect(Post.today.count).to eql(2) }
+    end
+
+    context 'timespan' do
+      it { expect(Event.today.count).to eql(5) }
+    end
+
+    context 'timespan strict' do
+      it { expect(Event.today(strict: true).count).to eql(0) }
+    end
+
+    it 'should be able to use an alternative field' do
+      expect(Event.today(field: 'created_at').count).to eql(2)
+    end
+
+    it 'should support :offset option' do
+      expect(Post.today(offset: -24.hours).count).to eql(1)
+    end
+  end
+
+  describe '#yesterday' do # 2013-12-31
+
+    context 'point-in-time' do
+      it { expect(Post.yesterday.count).to eql(1) }
+    end
+
+    context 'timespan' do
+      it { expect(Event.yesterday.count).to eql(5) }
+    end
+
+    context 'timespan strict' do
+      it { expect(Event.yesterday(strict: true).count).to eql(0) }
+    end
+
+    it 'should be able to use an alternative field' do
+      expect(Event.yesterday(field: 'created_at').count).to eql(1)
+    end
+
+    it 'should support :offset option' do
+      expect(Post.yesterday(offset: 24.hours).count).to eql(2)
+    end
+  end
+
+  describe '#tomorrow' do # 2014-01-02
+
+    context 'point-in-time' do
+      it { expect(Post.tomorrow.count).to eql(0) }
+    end
+
+    context 'timespan' do
+      it { expect(Event.tomorrow.count).to eql(5) }
+    end
+
+    context 'timespan strict' do
+      it { expect(Event.tomorrow(strict: true).count).to eql(0) }
+    end
+
+    it 'should be able to use an alternative field' do
+      expect(Event.tomorrow(field: 'created_at').count).to eql(0)
+    end
+
+    it 'should support :offset option' do
+      expect(Post.tomorrow(offset: -24.hours).count).to eql(2)
+    end
+  end
+end