by_star 2.2.0.rc1 → 2.2.0

data/UPGRADING

@@ -1,9 +1,11 @@
 Upgrading to ByStar 2.2.0
 -------------------------
 
-* For Mongoid only, ByStar's `.between` method has been removed and replaced with `.between_times`
-(previously `.between_times` was an alias to `.between`). Mongoid already provides a native `.between`
-finder method that we do not want to mask. ActiveRecord users may continue to use either method.
+* ActiveRecord: the `between` method has been deprecated as of version 2.2.0, and will be removed in version 3.3.0.
+Please use `between_times` instead.
+
+* Mongoid: the `between` method has been removed as of version 2.2.0, as it conflicts with the native Mongoid `between`
+method. Please use `between_times` instead.
 
 * Chronic gem (used for time string parsing) has been removed as a hard dependency for ByStar,
 however it is still supported. If you would like to use Chronic with ByStar, please explicitly

data/lib/by_star/base.rb

@@ -5,10 +5,12 @@ module ByStar
     include ByStar::Between
     include ByStar::Directional
 
-    def by_star_field(start_field = nil, end_field = nil, options = {})
-      @by_star_start_field ||= start_field
-      @by_star_end_field   ||= end_field
+    def by_star_field(*args)
+      options = args.extract_options!
+      @by_star_start_field ||= args[0]
+      @by_star_end_field   ||= args[1]
       @by_star_offset      ||= options[:offset]
+      @by_star_scope       ||= options[:scope]
     end
 
     def by_star_offset(options = {})
@@ -31,6 +33,19 @@ module ByStar
       field.to_s
     end
 
+    def by_star_scope(options={})
+      scope = options[:scope] || @by_star_scope || self
+      if scope.is_a?(Proc)
+        if scope.arity == 0
+          return instance_exec(&scope)
+        else
+          return instance_exec(self, &scope)
+        end
+      else
+        return scope
+      end
+    end
+
     protected
 
     # Wrapper function which extracts time and options for each by_star query.

data/lib/by_star/between.rb

@@ -14,18 +14,6 @@ module ByStar
       end
     end
 
-    def today(options={})
-      by_day(Time.zone.now, options)
-    end
-
-    def yesterday(options={})
-      by_day(Time.zone.now.yesterday, options)
-    end
-
-    def tomorrow(options={})
-      by_day(Time.zone.now.tomorrow, options)
-    end
-
     def by_week(*args)
       with_by_star_options(*args) do |time, options|
         time = ByStar::Normalization.week(time, options)
@@ -76,5 +64,57 @@ module ByStar
         between_times(time.beginning_of_year, time.end_of_year, options)
       end
     end
+
+    def today(options={})
+      by_day(Time.zone.now, options)
+    end
+
+    def yesterday(options={})
+      by_day(Time.zone.now.yesterday, options)
+    end
+
+    def tomorrow(options={})
+      by_day(Time.zone.now.tomorrow, options)
+    end
+
+    def past_day(options={})
+      between_times(Time.zone.now - 1.day, Time.zone.now, options)
+    end
+
+    def past_week(options={})
+      between_times(Time.zone.now - 1.week, Time.zone.now, options)
+    end
+
+    def past_fortnight(options={})
+      between_times(Time.zone.now - 2.weeks, Time.zone.now, options)
+    end
+
+    def past_month(options={})
+      between_times(Time.zone.now - 1.month, Time.zone.now, options)
+    end
+
+    def past_year(options={})
+      between_times(Time.zone.now - 1.year, Time.zone.now, options)
+    end
+
+    def next_day(options={})
+      between_times(Time.zone.now, Time.zone.now + 1.day, options)
+    end
+
+    def next_week(options={})
+      between_times(Time.zone.now, Time.zone.now  + 1.week, options)
+    end
+
+    def next_fortnight(options={})
+      between_times(Time.zone.now, Time.zone.now + 2.weeks, options)
+    end
+
+    def next_month(options={})
+      between_times(Time.zone.now, Time.zone.now + 1.month, options)
+    end
+
+    def next_year(options={})
+      between_times(Time.zone.now, Time.zone.now + 1.year, options)
+    end
   end
 end

data/lib/by_star/kernel.rb

@@ -18,14 +18,14 @@ module ByStar
       # A "Fortnight" is defined as a two week period, with the first fortnight of the
       # year beginning on 1st January.
       def beginning_of_fortnight
-        beginning_of_year + ((self - beginning_of_year) / 2.weeks).to_i * 2.weeks
+        (beginning_of_year.to_date + 14 * ((self - beginning_of_year) / 2.weeks).to_i).beginning_of_day
       end
 
       def end_of_fortnight
-        (beginning_of_fortnight + 13.days).end_of_day
+        (beginning_of_fortnight.to_date + 13).end_of_day
       end
 
-      # A "Calendar Month" is defined as a month as it appears on a calendar, including days
+      # A "Calendar Month" is defined as a month as it appears on a calendar, including days form
       # previous/following months which are part of the first/last weeks of the given month.
       def beginning_of_calendar_month(*args)
         beginning_of_month.beginning_of_week(*args)

data/lib/by_star/orm/active_record/by_star.rb

@@ -9,16 +9,23 @@ module ByStar
       #
       # Currently only supports Time objects.
       def between_times_query(start, finish, options={})
-        scope = if options[:strict] || by_star_start_field == by_star_end_field
-          where("#{by_star_start_field} >= ? AND #{by_star_end_field} <= ?", start, finish)
+        start_field = by_star_start_field(options)
+        end_field = by_star_end_field(options)
+
+        scope = by_star_scope(options)
+        scope = if options[:strict] || start_field == end_field
+          scope.where("#{start_field} >= ? AND #{end_field} <= ?", start, finish)
         else
-          where("#{by_star_end_field} > ? AND #{by_star_start_field} < ?", start, finish)
+          scope.where("#{end_field} > ? AND #{start_field} < ?", start, finish)
         end
         scope = scope.order(options[:order]) if options[:order]
         scope
       end
 
-      alias_method :between, :between_times
+      def between(*args)
+        ActiveSupport::Deprecation.warn 'ByStar `between` method will be removed in v3.0.0. Please use `between_times`'
+        between_times(*args)
+      end
 
       protected
 
@@ -27,26 +34,26 @@ module ByStar
       end
 
       def before_query(time, options={})
-        field = by_star_start_field
-        where("#{field} <= ?", time)
+        field = by_star_start_field(options)
+        by_star_scope(options).where("#{field} <= ?", time)
       end
 
       def after_query(time, options={})
-        field = by_star_start_field
-        where("#{field} >= ?", time)
+        field = by_star_start_field(options)
+        by_star_scope(options).where("#{field} >= ?", time)
       end
     end
 
     def previous(options={})
       field = self.class.by_star_start_field
       value = self.send(field.split(".").last)
-      self.class.where("#{field} < ?", value).reorder("#{field} DESC").first
+      self.class.by_star_scope(options).where("#{field} < ?", value).reorder("#{field} DESC").first
     end
 
     def next(options={})
       field = self.class.by_star_start_field
       value = self.send(field.split(".").last)
-      self.class.where("#{field} > ?", value).reorder("#{field} ASC").first
+      self.class.by_star_scope(options).where("#{field} > ?", value).reorder("#{field} ASC").first
     end
   end
 end

data/lib/by_star/orm/mongoid/by_star.rb

@@ -10,10 +10,14 @@ module Mongoid
       include ::ByStar::Base
 
       def between_times_query(start, finish, options={})
-        scope = if options[:strict] || by_star_start_field == by_star_end_field
-          gte(by_star_start_field => start).lte(by_star_end_field => finish)
+        start_field = by_star_start_field(options)
+        end_field = by_star_end_field(options)
+
+        scope = by_star_scope(options)
+        scope = if options[:strict] || start_field == end_field
+          scope.gte(start_field => start).lte(end_field => finish)
         else
-          gt(by_star_end_field => start).lt(by_star_start_field => finish)
+          scope.gt(end_field => start).lt(start_field => finish)
         end
         scope = scope.order_by(field => options[:order]) if options[:order]
         scope
@@ -36,24 +40,24 @@ module Mongoid
       end
 
       def before_query(time, options={})
-        field = by_star_start_field
-        lte(field => time)
+        field = by_star_start_field(options)
+        by_star_scope(options).lte(field => time)
       end
 
       def after_query(time, options={})
-        field = by_star_start_field
-        gte(field => time)
+        field = by_star_start_field(options)
+        by_star_scope(options).gte(field => time)
       end
     end
 
     def previous(options={})
       field = self.class.by_star_start_field
-      self.class.lt(field => self.send(field)).desc(field).first
+      self.class.by_star_scope(options).lt(field => self.send(field)).desc(field).first
     end
 
     def next(options={})
       field = self.class.by_star_start_field
-      self.class.gt(field => self.send(field)).asc(field).first
+      self.class.by_star_scope(options).gt(field => self.send(field)).asc(field).first
     end
   end
 end

data/lib/by_star/version.rb

@@ -1,3 +1,3 @@
 module ByStar
-  VERSION = '2.2.0.rc1'
+  VERSION = '2.2.0'
 end

data/spec/fixtures/active_record/models.rb

@@ -1,6 +1,10 @@
 class Post < ActiveRecord::Base
 end
 
+class Appointment < ActiveRecord::Base
+  by_star_field scope: ->{ where(day_of_month: 1) }
+end
+
 class Event < ActiveRecord::Base
   by_star_field :start_time, :end_time, offset: 3.hours
 end

data/spec/fixtures/active_record/schema.rb

@@ -3,9 +3,17 @@ ActiveRecord::Schema.define do
 
   create_table :posts, :force => true do |t|
     t.timestamps
+    t.integer :day_of_month
   end
 
   create_table :events, :force => true do |t|
+    t.timestamps
     t.datetime :start_time, :end_time
+    t.integer  :day_of_month
+  end
+
+  create_table :appointments, :force => true do |t|
+    t.timestamps
+    t.integer :day_of_month
   end
 end

data/spec/fixtures/mongoid/models.rb

@@ -2,14 +2,28 @@ class Post
   include Mongoid::Document
   include Mongoid::Timestamps
   include Mongoid::ByStar
+
+  field :day_of_month,        type: Integer
+end
+
+class Appointment
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  include Mongoid::ByStar
+
+  field :day_of_month,        type: Integer
+
+  by_star_field scope: ->{ where(day_of_month: 1) }
 end
 
 class Event
   include Mongoid::Document
+  include Mongoid::Timestamps
   include Mongoid::ByStar
 
   field :st, as: :start_time, type: Time
   field :end_time,            type: Time
+  field :day_of_month,        type: Integer
 
   by_star_field :start_time, :end_time, offset: 3.hours
 end

data/spec/fixtures/shared/seeds.rb

@@ -1,4 +1,13 @@
-%w(2013-12-31
+%w(2013-11-01
+   2013-11-30
+   2013-12-01
+   2013-12-05
+   2013-12-08
+   2013-12-16
+   2013-12-22
+   2013-12-25
+   2013-12-28
+   2013-12-31
    2014-01-01
    2014-01-01
    2014-01-05
@@ -11,6 +20,7 @@
    2014-03-15
    2014-04-01
    2014-04-15).map{|d| Time.zone.parse(d) + 17.hours }.each do |d|
-  Post.create!(:created_at => d)
-  Event.create!(:start_time => d - 5.days, :end_time => d + 5.days)
+  Post.create!(:created_at => d, day_of_month: d.day)
+  Appointment.create!(:created_at => d, day_of_month: d.day)
+  Event.create!(:created_at => d, :start_time => d - 5.days, :end_time => d + 5.days, day_of_month: d.day)
 end

data/spec/integration/active_record/active_record_spec.rb

@@ -4,6 +4,7 @@ Dir[File.dirname(__FILE__) + '/../shared/*.rb'].each {|file| require file }
 describe ActiveRecord do
   before(:all) do
     ActiveRecord::Base.default_timezone = :utc
+    # ActiveRecord::Base.logger = Logger.new(STDOUT)
 
     db_config = YAML::load_file(File.dirname(__FILE__) + '/../../database.yml')
     if db_config.has_key?('sqlite') && db_config['sqlite'].has_key?('database')
@@ -28,7 +29,9 @@ describe ActiveRecord do
   it_behaves_like 'by week'
   it_behaves_like 'by weekend'
   it_behaves_like 'by year'
+  it_behaves_like 'relative'
   it_behaves_like 'offset parameter'
+  it_behaves_like 'scope parameter'
 
   it 'should be able to order the result set' do
     scope = Post.by_year(Time.zone.now.year, :order => 'created_at DESC')

data/spec/integration/mongoid/mongoid_spec.rb

@@ -5,6 +5,7 @@ describe 'Mongoid' do
 
   before(:all) do
     DATABASE_NAME = "mongoid_#{Process.pid}"
+    # Moped.logger = Logger.new(STDOUT)
 
     Mongoid.configure do |config|
       config.connect_to DATABASE_NAME
@@ -27,7 +28,9 @@ describe 'Mongoid' do
   it_behaves_like 'by week'
   it_behaves_like 'by weekend'
   it_behaves_like 'by year'
+  it_behaves_like 'relative'
   it_behaves_like 'offset parameter'
+  it_behaves_like 'scope parameter'
 
   describe '#between_times' do
     subject { Post.between_times(Time.parse('2014-01-01'), Time.parse('2014-01-06')) }

data/spec/integration/shared/by_calendar_month.rb

@@ -11,7 +11,7 @@ shared_examples_for 'by calendar month' do
 
     context 'timespan' do
       subject { Event.by_calendar_month(1) }
-      its(:count){ should eq 8 }
+      its(:count){ should eq 10 }
     end
 
     context 'timespan strict' do
@@ -23,17 +23,17 @@ shared_examples_for 'by calendar month' do
 
       context 'point-in-time' do
         subject { Post.by_calendar_month(12, year: 2013) }
-        its(:count){ should eq 4 }
+        its(:count){ should eq 12 }
       end
 
       context 'timespan' do
         subject { Event.by_calendar_month('December', year: 2013) }
-        its(:count){ should eq 5 }
+        its(:count){ should eq 13 }
       end
 
       context 'timespan strict' do
         subject { Event.by_calendar_month('Dec', year: 2013, strict: true) }
-        its(:count){ should eq 1 }
+        its(:count){ should eq 9 }
       end
     end
 
@@ -44,7 +44,7 @@ shared_examples_for 'by calendar month' do
     end
 
     it 'should be able to use an alternative field' do
-      Event.by_calendar_month(:field => 'end_time').count.should eq 8
+      Event.by_calendar_month(:field => 'end_time').count.should eq 9
     end
 
     context ':start_day option' do

data/spec/integration/shared/by_day.rb

@@ -11,7 +11,7 @@ shared_examples_for 'by day' do
 
     context 'timespan' do
       subject { Event.by_day(Time.parse '2014-01-01') }
-      its(:count){ should eq 4 }
+      its(:count){ should eq 5 }
     end
 
     context 'timespan strict' do
@@ -20,7 +20,7 @@ shared_examples_for 'by day' do
     end
 
     it 'should be able to use an alternative field' do
-      Event.by_day(:field => 'end_time').count.should eq 4
+      Event.by_day(:field => 'end_time').count.should eq 0
     end
 
     it 'should support :offset option' do
@@ -37,13 +37,21 @@ shared_examples_for 'by day' do
 
     context 'timespan' do
       subject { Event.today }
-      its(:count){ should eq 4 }
+      its(:count){ should eq 5 }
     end
 
     context 'timespan strict' do
       subject { Event.today(strict: true) }
       its(:count){ should eq 0 }
     end
+
+    it 'should be able to use an alternative field' do
+      Event.today(:field => 'created_at').count.should eq 2
+    end
+
+    it 'should support :offset option' do
+      Post.today(:offset => -24.hours).count.should eq 1
+    end
   end
 
   describe '#yesterday' do # 2013-12-31
@@ -55,13 +63,21 @@ shared_examples_for 'by day' do
 
     context 'timespan' do
       subject { Event.yesterday }
-      its(:count){ should eq 4 }
+      its(:count){ should eq 5 }
     end
 
     context 'timespan strict' do
       subject { Event.yesterday(strict: true) }
       its(:count){ should eq 0 }
     end
+
+    it 'should be able to use an alternative field' do
+      Event.yesterday(:field => 'created_at').count.should eq 1
+    end
+
+    it 'should support :offset option' do
+      Post.yesterday(:offset => 24.hours).count.should eq 2
+    end
   end
 
   describe '#tomorrow' do # 2014-01-02
@@ -73,12 +89,20 @@ shared_examples_for 'by day' do
 
     context 'timespan' do
       subject { Event.tomorrow }
-      its(:count){ should eq 4 }
+      its(:count){ should eq 5 }
     end
 
     context 'timespan strict' do
       subject { Event.tomorrow(strict: true) }
       its(:count){ should eq 0 }
     end
+
+    it 'should be able to use an alternative field' do
+      Event.tomorrow(:field => 'created_at').count.should eq 0
+    end
+
+    it 'should support :offset option' do
+      Post.tomorrow(:offset => -24.hours).count.should eq 2
+    end
   end
 end