by_star 2.2.0 → 4.0.0

data/spec/integration/shared/by_month.rb

@@ -1,50 +1,50 @@
-require 'spec_helper'
-
-shared_examples_for 'by month' do
-
-  describe '#by_month' do
-
-    context 'point-in-time' do
-      subject { Post.by_month('Feb') }
-      its(:count){ should eq 2 }
-    end
-
-    context 'timespan' do
-      subject { Event.by_month(1) }
-      its(:count){ should eq 9 }
-    end
-
-    context 'timespan strict' do
-      subject { Event.by_month(Date.parse('2014-02-01'), strict: true) }
-      its(:count){ should eq 1 }
-    end
-
-    context 'with :year option' do
-
-      context 'point-in-time' do
-        subject { Post.by_month(12, year: 2013) }
-        its(:count){ should eq 8 }
-      end
-
-      context 'timespan' do
-        subject { Event.by_month('December', year: 2013) }
-        its(:count){ should eq 12 }
-      end
-
-      context 'timespan strict' do
-        subject { Event.by_month('Dec', year: 2013, strict: true) }
-        its(:count){ should eq 4 }
-      end
-    end
-
-    it 'should raise an error when given an invalid argument' do
-      ->{ Post.by_month(0) }.should raise_error(ByStar::ParseError, 'Month must be a number between 1 and 12 or a month name')
-      ->{ Post.by_month(13) }.should raise_error(ByStar::ParseError, 'Month must be a number between 1 and 12 or a month name')
-      ->{ Post.by_month('foobar') }.should 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
-      Event.by_month(:field => 'end_time').count.should eq 8
-    end
-  end
-end
+require 'spec_helper'
+
+shared_examples_for 'by month' do
+
+  describe '#by_month' do
+
+    context 'point-in-time' do
+      subject { Post.by_month('Feb') }
+      it { expect(subject.count).to eql(2) }
+    end
+
+    context 'timespan' do
+      subject { Event.by_month(1) }
+      it { expect(subject.count).to eql(9) }
+    end
+
+    context 'timespan strict' do
+      subject { Event.by_month(Date.parse('2014-02-01'), strict: true) }
+      it { expect(subject.count).to eql(1) }
+    end
+
+    context 'with :year option' do
+
+      context 'point-in-time' do
+        subject { Post.by_month(12, year: 2013) }
+        it { expect(subject.count).to eql(8) }
+      end
+
+      context 'timespan' do
+        subject { Event.by_month('December', year: 2013) }
+        it { expect(subject.count).to eql(12) }
+      end
+
+      context 'timespan strict' do
+        subject { Event.by_month('Dec', year: 2013, strict: true) }
+        it { expect(subject.count).to eql(4) }
+      end
+    end
+
+    it 'should raise an error when given an invalid argument' do
+      expect{ Post.by_month(0) }.to raise_error(ByStar::ParseError, 'Month must be a number between 1 and 12 or a month name')
+      expect{ Post.by_month(13) }.to raise_error(ByStar::ParseError, 'Month must be a number between 1 and 12 or a month name')
+      expect{ Post.by_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_month(field: 'end_time').count).to eq 8
+    end
+  end
+end

data/spec/integration/shared/by_quarter.rb

@@ -1,49 +1,49 @@
-require 'spec_helper'
-
-shared_examples_for 'by quarter' do
-
-  describe '#by_quarter' do
-
-    context 'point-in-time' do
-      subject { Post.by_quarter(2) }
-      its(:count){ should eq 2 }
-    end
-
-    context 'timespan' do
-      subject { Event.by_quarter(1) }
-      its(:count){ should eq 13 }
-    end
-
-    context 'timespan strict' do
-      subject { Event.by_quarter(Date.parse('2014-02-01'), strict: true) }
-      its(:count){ should eq 7 }
-    end
-
-    context 'with :year option' do
-
-      context 'point-in-time' do
-        subject { Post.by_quarter(4, year: 2013) }
-        its(:count){ should eq 10 }
-      end
-
-      context 'timespan' do
-        subject { Event.by_quarter(4, year: 2013) }
-        its(:count){ should eq 13 }
-      end
-
-      context 'timespan strict' do
-        subject { Event.by_quarter(4, year: 2013, strict: true) }
-        its(:count){ should eq 8 }
-      end
-    end
-
-    it 'should raise an error when given an invalid argument' do
-      ->{ Post.by_quarter(0) }.should raise_error(ByStar::ParseError, 'Quarter number must be between 1 and 4')
-      ->{ Post.by_quarter(5) }.should raise_error(ByStar::ParseError, 'Quarter number must be between 1 and 4')
-    end
-
-    it 'should be able to use an alternative field' do
-      Event.by_quarter(1, :field => 'end_time').count.should eq 12
-    end
-  end
-end
+require 'spec_helper'
+
+shared_examples_for 'by quarter' do
+
+  describe '#by_quarter' do
+
+    context 'point-in-time' do
+      subject { Post.by_quarter(2) }
+      it { expect(subject.count).to eql(2) }
+    end
+
+    context 'timespan' do
+      subject { Event.by_quarter(1) }
+      it { expect(subject.count).to eql(13) }
+    end
+
+    context 'timespan strict' do
+      subject { Event.by_quarter(Date.parse('2014-02-01'), strict: true) }
+      it { expect(subject.count).to eql(7) }
+    end
+
+    context 'with :year option' do
+
+      context 'point-in-time' do
+        subject { Post.by_quarter(4, year: 2013) }
+        it { expect(subject.count).to eql(10) }
+      end
+
+      context 'timespan' do
+        subject { Event.by_quarter(4, year: 2013) }
+        it { expect(subject.count).to eql(13) }
+      end
+
+      context 'timespan strict' do
+        subject { Event.by_quarter(4, year: 2013, strict: true) }
+        it { expect(subject.count).to eql(8) }
+      end
+    end
+
+    it 'should raise an error when given an invalid argument' do
+      expect{ Post.by_quarter(0) }.to raise_error(ByStar::ParseError, 'Quarter number must be between 1 and 4')
+      expect{ Post.by_quarter(5) }.to raise_error(ByStar::ParseError, 'Quarter number must be between 1 and 4')
+    end
+
+    it 'should be able to use an alternative field' do
+      expect(Event.by_quarter(1, field: 'end_time').count).to eq 12
+    end
+  end
+end

data/spec/integration/shared/by_week.rb

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

data/spec/integration/shared/by_weekend.rb

@@ -1,49 +1,49 @@
-require 'spec_helper'
-
-shared_examples_for 'by weekend' do
-
-  describe '#by_weekend' do
-
-    context 'point-in-time' do
-      subject { Post.by_weekend('2014-01-01') }
-      its(:count){ should eq 1 }
-    end
-
-    context 'timespan' do
-      subject { Event.by_weekend(0) }
-      its(:count){ should eq 5 }
-    end
-
-    context 'timespan strict' do
-      subject { Event.by_weekend(Date.parse('2014-01-01'), strict: true) }
-      its(:count){ should eq 0 }
-    end
-
-    context 'with :year option' do
-
-      context 'point-in-time' do
-        subject { Post.by_weekend(52, year: 2013) }
-        its(:count){ should eq 1 }
-      end
-
-      context 'timespan' do
-        subject { Event.by_weekend(52, year: 2013) }
-        its(:count){ should eq 5 }
-      end
-
-      context 'timespan strict' do
-        subject { Event.by_weekend(52, year: 2013, strict: true) }
-        its(:count){ should eq 0 }
-      end
-    end
-
-    it 'should raise an error when given an invalid argument' do
-      lambda { Post.by_weekend(-1) }.should raise_error(ByStar::ParseError, 'Week number must be between 0 and 52')
-      lambda { Post.by_weekend(53) }.should raise_error(ByStar::ParseError, 'Week number must be between 0 and 52')
-    end
-
-    it 'should be able to use an alternative field' do
-      Event.by_weekend(:field => 'end_time').count.should eq 1
-    end
-  end
-end
+require 'spec_helper'
+
+shared_examples_for 'by weekend' do
+
+  describe '#by_weekend' do
+
+    context 'point-in-time' do
+      subject { Post.by_weekend('2014-01-01') }
+      it { expect(subject.count).to eql(1) }
+    end
+
+    context 'timespan' do
+      subject { Event.by_weekend(0) }
+      it { expect(subject.count).to eql(5) }
+    end
+
+    context 'timespan strict' do
+      subject { Event.by_weekend(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_weekend(52, year: 2013) }
+        it { expect(subject.count).to eql(1) }
+      end
+
+      context 'timespan' do
+        subject { Event.by_weekend(52, year: 2013) }
+        it { expect(subject.count).to eql(5) }
+      end
+
+      context 'timespan strict' do
+        subject { Event.by_weekend(52, 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_weekend(-1) }.to raise_error(ByStar::ParseError, 'Week number must be between 0 and 52')
+      expect { Post.by_weekend(53) }.to raise_error(ByStar::ParseError, 'Week number must be between 0 and 52')
+    end
+
+    it 'should be able to use an alternative field' do
+      expect(Event.by_weekend(field: 'end_time').count).to eq 1
+    end
+  end
+end

data/spec/integration/shared/by_year.rb

@@ -1,48 +1,48 @@
-require 'spec_helper'
-
-shared_examples_for 'by year' do
-
-  describe '#by_year' do
-
-    context 'point-in-time' do
-      subject { Post.by_year('2014') }
-      its(:count){ should eq 12 }
-    end
-
-    context 'timespan' do
-      subject { Event.by_year(13) }
-      its(:count){ should eq 13 }
-    end
-
-    context 'timespan strict' do
-      subject { Event.by_year(Date.parse('2014-02-01'), strict: true) }
-      its(:count){ should eq 9 }
-    end
-
-    context 'with :year option' do
-
-      context 'point-in-time' do
-        subject { Post.by_year(year: 2013) }
-        its(:count){ should eq 10 }
-      end
-
-      context 'timespan' do
-        subject { Event.by_year(year: 2014) }
-        its(:count){ should eq 14 }
-      end
-
-      context 'timespan strict' do
-        subject { Event.by_year(year: 2013, strict: true) }
-        its(:count){ should eq 8 }
-      end
-    end
-
-    it 'should be able to use an alternative field' do
-      Event.by_year(:field => 'end_time').count.should eq 14
-    end
-
-    it 'can use a 2-digit year' do
-      Post.by_year(13).count.should eq 10
-    end
-  end
-end
+require 'spec_helper'
+
+shared_examples_for 'by year' do
+
+  describe '#by_year' do
+
+    context 'point-in-time' do
+      subject { Post.by_year('2014') }
+      it { expect(subject.count).to eql(12) }
+    end
+
+    context 'timespan' do
+      subject { Event.by_year(13) }
+      it { expect(subject.count).to eql(13) }
+    end
+
+    context 'timespan strict' do
+      subject { Event.by_year(Date.parse('2014-02-01'), strict: true) }
+      it { expect(subject.count).to eql(9) }
+    end
+
+    context 'integer' do
+
+      context 'point-in-time' do
+        subject { Post.by_year(2013) }
+        it { expect(subject.count).to eql(10) }
+      end
+
+      context 'timespan' do
+        subject { Event.by_year(2014) }
+        it { expect(subject.count).to eql(14) }
+      end
+
+      context 'timespan strict' do
+        subject { Event.by_year(2013, strict: true) }
+        it { expect(subject.count).to eql(8) }
+      end
+    end
+
+    it 'should be able to use an alternative field' do
+      expect(Event.by_year(field: 'end_time').count).to eq 14
+    end
+
+    it 'can use a 2-digit year' do
+      expect(Post.by_year(13).count).to eq 10
+    end
+  end
+end

data/spec/integration/shared/index_scope_parameter.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+shared_examples_for 'index_scope parameter' do
+
+  describe ':scope' do
+
+    it 'should memoize the scope variable' do
+      expect(Event.instance_variable_get(:@by_star_index_scope)).to be_nil
+      expect(Post.instance_variable_get(:@by_star_index_scope)).to be_nil
+      expect(Appointment.instance_variable_get(:@by_star_index_scope)).to be_a Proc
+    end
+
+    context 'between_times with index_scope' do
+
+      context 'nil' do
+        subject { Event.between_times(Date.parse('2013-12-01'), Date.parse('2014-01-31'), index_scope: nil) }
+        it { expect(subject.count).to eql(16) }
+      end
+
+      context 'false' do
+        subject { Event.between_times(Date.parse('2013-12-01'), Date.parse('2014-01-31'), index_scope: false) }
+        it { expect(subject.count).to eql(16) }
+      end
+
+      context 'Time' do
+        subject { Event.between_times(Date.parse('2013-12-01'), Date.parse('2014-01-31'), index_scope: Time.zone.parse('2013-11-30 17:00:00')) }
+        it { expect(subject.count).to eql(14) }
+      end
+
+      context 'DateTime' do
+        subject { Event.between_times(Date.parse('2013-12-01'), Date.parse('2014-01-31'), index_scope: Time.zone.parse('2013-11-30 17:00:00').to_datetime) }
+        it { expect(subject.count).to eql(14) }
+      end
+
+      context 'Date' do
+        subject { Event.between_times(Date.parse('2013-12-01'), Date.parse('2014-01-31'), index_scope: Date.parse('2013-11-30')) }
+        it { expect(subject.count).to eql(14) }
+      end
+
+      context 'ActiveSupport::Duration' do
+        subject { Event.between_times(Date.parse('2013-12-01'), Date.parse('2014-01-31'), index_scope: 3.hours) }
+        it { expect(subject.count).to eql(13) }
+      end
+
+      context 'Numeric' do
+        subject { Event.between_times(Date.parse('2013-12-01'), Date.parse('2014-01-31'), index_scope: 3600) }
+        it { expect(subject.count).to eql(13) }
+      end
+
+      context ':beginning_of_day' do
+        subject { Event.between_times(Date.parse('2013-12-01'), Date.parse('2014-01-31'), index_scope: :beginning_of_day) }
+        it { expect(subject.count).to eql(13) }
+      end
+
+      context 'unsupported type' do
+        subject { Event.between_times(Date.parse('2013-12-01'), Date.parse('2014-01-31'), index_scope: Integer) }
+        it { expect{subject.count}.to raise_error(RuntimeError) }
+      end
+    end
+
+    context 'at_time with index_scope' do
+
+      context 'nil' do
+        subject { Event.at_time(Time.zone.parse('2013-12-01 14:00'), index_scope: nil) }
+        it { expect(subject.count).to eql(3) }
+      end
+
+      context 'false' do
+        subject { Event.at_time(Time.zone.parse('2013-12-01 14:00'), index_scope: false) }
+        it { expect(subject.count).to eql(3) }
+      end
+
+      context 'Time' do
+        subject { Event.at_time(Time.zone.parse('2013-12-01 14:00'), index_scope: Time.zone.parse('2013-10-30 17:00:00')) }
+        it { expect(subject.count).to eql(3) }
+      end
+
+      context 'DateTime' do
+        subject { Event.at_time(Time.zone.parse('2013-12-01 14:00'), index_scope: Time.zone.parse('2013-11-30 17:00:00').to_datetime) }
+        it { expect(subject.count).to eql(1) }
+      end
+
+      context 'Date' do
+        subject { Event.at_time(Time.zone.parse('2013-12-01 14:00'), index_scope: Date.parse('2013-11-30')) }
+        it { expect(subject.count).to eql(1) }
+      end
+
+      context 'ActiveSupport::Duration' do
+        subject { Event.at_time(Time.zone.parse('2013-12-01 14:00'), index_scope: 100.hours) }
+        it { expect(subject.count).to eql(1) }
+      end
+
+      context 'Numeric' do
+        subject { Event.at_time(Time.zone.parse('2013-12-01 14:00'), index_scope: 60 * 60 * 1000) }
+        it { expect(subject.count).to eql(3) }
+      end
+
+      context ':beginning_of_day' do
+        let!(:custom_event){ t = Time.zone.parse('2013-12-30 17:00'); Event.create!(start_time: t - 1.hour, end_time: t + 1.hour) }
+        subject { Event.at_time(Time.zone.parse('2013-12-30 16:00'), index_scope: :beginning_of_day) }
+        it { expect(subject.count).to eql(1) }
+        after { custom_event.delete }
+      end
+
+      context 'unsupported type' do
+        subject { Event.at_time(Time.zone.parse('2013-12-01 14:00'), index_scope: Integer) }
+        it { expect{subject.count}.to raise_error(RuntimeError) }
+      end
+    end
+  end
+end