by_star 3.0.0 → 4.0.0

data/lib/by_star/base.rb

@@ -11,6 +11,7 @@ module ByStar
       @by_star_end_field   ||= args[1]
       @by_star_offset      ||= options[:offset]
       @by_star_scope       ||= options[:scope]
+      @by_star_index_scope ||= options[:index_scope]
     end
 
     def by_star_offset(options = {})
@@ -33,21 +34,6 @@ 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)
-        elsif options[:scope_args]
-          return instance_exec(*Array(options[:scope_args]), &scope)
-        else
-          raise 'ByStar :scope Proc requires :scope_args to be specified.'
-        end
-      else
-        return scope
-      end
-    end
-
     protected
 
     # Wrapper function which extracts time and options for each by_star query.
@@ -64,5 +50,20 @@ module ByStar
       time = args.first || Time.zone.now
       block.call(time, options)
     end
+
+    def by_star_eval_index_scope(start_time, end_time, options)
+      value = options[:index_scope] || @by_star_index_scope
+      value = value.call(start_time, end_time, options) if value.is_a?(Proc)
+      case value
+        when nil, false then nil
+        when Time, DateTime, Date then value.in_time_zone
+        when ActiveSupport::Duration then start_time - value
+        when Numeric then start_time - value.seconds
+        when :beginning_of_day
+          offset = options[:offset] || 0
+          (start_time - offset).beginning_of_day + offset
+        else raise 'ByStar :index_scope option value is not a supported type.'
+      end
+    end
   end
 end

data/lib/by_star/between.rb

@@ -5,19 +5,25 @@ module ByStar
     def between_times(*args)
       options = args.extract_options!.symbolize_keys!
 
-      start_time, end_time = case args[0]
-                               when Array, Range then [args[0].first, args[0].last]
-                               else args[0..1]
-                             end
+      start_time, end_time = ByStar::Normalization.extract_range(args)
+      offset = options[:offset] || 0
 
-      offset = (options[:offset] || 0).seconds
-      start_time += offset if start_time
-      end_time   += offset if end_time
+      if start_time.is_a?(Date)
+        start_time = ByStar::Normalization.apply_offset_start(start_time.in_time_zone, offset)
+      elsif start_time
+        start_time += offset.seconds
+      end
+
+      if end_time.is_a?(Date)
+        end_time = ByStar::Normalization.apply_offset_end(end_time.in_time_zone, offset)
+      elsif end_time
+        end_time += offset.seconds
+      end
 
       start_field = by_star_start_field(options)
       end_field = by_star_end_field(options)
-      scope = by_star_scope(options)
 
+      scope = self
       scope = if !start_time && !end_time
                 scope # do nothing
               elsif !end_time
@@ -29,26 +35,49 @@ module ByStar
               elsif options[:strict]
                 by_star_span_strict_query(scope, start_field, end_field, start_time, end_time)
               else
-                by_star_span_overlap_query(scope, start_field, end_field, start_time, end_time, options)
+                by_star_span_loose_query(scope, start_field, end_field, start_time, end_time, options)
               end
 
       scope = by_star_order(scope, options[:order]) if options[:order]
-
       scope
     end
 
+    def between_dates(*args)
+      options = args.extract_options!
+      start_date, end_date = ByStar::Normalization.extract_range(args)
+      start_date = ByStar::Normalization.date(start_date)
+      end_date   = ByStar::Normalization.date(end_date)
+      between_times(start_date, end_date, options)
+    end
+
+    def at_time(*args)
+      with_by_star_options(*args) do |time, options|
+        start_field = by_star_start_field(options)
+        end_field = by_star_end_field(options)
+
+        scope = self
+        scope = if start_field == end_field
+                  by_star_point_overlap_query(scope, start_field, time)
+                else
+                  by_star_span_overlap_query(scope, start_field, end_field, time, options)
+                end
+        scope = by_star_order(scope, options[:order]) if options[:order]
+        scope
+      end
+    end
+
     def by_day(*args)
       with_by_star_options(*args) do |time, options|
-        time = ByStar::Normalization.time(time)
-        between_times(time.beginning_of_day, time.end_of_day, options)
+        date = ByStar::Normalization.date(time)
+        between_dates(date, date, options)
       end
     end
 
     def by_week(*args)
       with_by_star_options(*args) do |time, options|
-        time = ByStar::Normalization.week(time, options)
+        date = ByStar::Normalization.week(time, options)
         start_day = Array(options[:start_day])
-        between_times(time.beginning_of_week(*start_day), time.end_of_week(*start_day), options)
+        between_dates(date.beginning_of_week(*start_day), date.end_of_week(*start_day), options)
       end
     end
 
@@ -60,97 +89,97 @@ module ByStar
 
     def by_weekend(*args)
       with_by_star_options(*args) do |time, options|
-        time = ByStar::Normalization.week(time, options)
-        between_times(time.beginning_of_weekend, time.end_of_weekend, options)
+        date = ByStar::Normalization.week(time, options)
+        between_dates(date.beginning_of_weekend, date.end_of_weekend, options)
       end
     end
 
     def by_fortnight(*args)
       with_by_star_options(*args) do |time, options|
-        time = ByStar::Normalization.fortnight(time, options)
-        between_times(time.beginning_of_fortnight, time.end_of_fortnight, options)
+        date = ByStar::Normalization.fortnight(time, options)
+        between_dates(date.beginning_of_fortnight, date.end_of_fortnight, options)
       end
     end
 
     def by_month(*args)
       with_by_star_options(*args) do |time, options|
-        time = ByStar::Normalization.month(time, options)
-        between_times(time.beginning_of_month, time.end_of_month, options)
+        date = ByStar::Normalization.month(time, options)
+        between_dates(date.beginning_of_month, date.end_of_month, options)
       end
     end
 
     def by_calendar_month(*args)
       with_by_star_options(*args) do |time, options|
-        time = ByStar::Normalization.month(time, options)
+        date = ByStar::Normalization.month(time, options)
         start_day = Array(options[:start_day])
-        between_times(time.beginning_of_calendar_month(*start_day), time.end_of_calendar_month(*start_day), options)
+        between_dates(date.beginning_of_calendar_month(*start_day), date.end_of_calendar_month(*start_day), options)
       end
     end
 
     def by_quarter(*args)
       with_by_star_options(*args) do |time, options|
-        time = ByStar::Normalization.quarter(time, options)
-        between_times(time.beginning_of_quarter, time.end_of_quarter, options)
+        date = ByStar::Normalization.quarter(time, options)
+        between_dates(date.beginning_of_quarter, date.end_of_quarter, options)
       end
     end
 
     def by_year(*args)
       with_by_star_options(*args) do |time, options|
-        time = ByStar::Normalization.year(time, options)
-        between_times(time.beginning_of_year, time.end_of_year, options)
+        date = ByStar::Normalization.year(time, options)
+        between_dates(date.beginning_of_year, date.to_date.end_of_year, options)
       end
     end
 
-    def today(options={})
-      by_day(Time.zone.now, options)
+    def today(options = {})
+      by_day(Date.current, options)
     end
 
-    def yesterday(options={})
-      by_day(Time.zone.now.yesterday, options)
+    def yesterday(options = {})
+      by_day(Date.yesterday, options)
     end
 
-    def tomorrow(options={})
-      by_day(Time.zone.now.tomorrow, options)
+    def tomorrow(options = {})
+      by_day(Date.tomorrow, options)
     end
 
-    def past_day(options={})
-      between_times(Time.zone.now - 1.day, Time.zone.now, options)
+    def past_day(options = {})
+      between_times(Time.current - 1.day, Time.current, options)
     end
 
-    def past_week(options={})
-      between_times(Time.zone.now - 1.week, Time.zone.now, options)
+    def past_week(options = {})
+      between_times(Time.current - 1.week, Time.current, options)
     end
 
-    def past_fortnight(options={})
-      between_times(Time.zone.now - 2.weeks, Time.zone.now, options)
+    def past_fortnight(options = {})
+      between_times(Time.current - 2.weeks, Time.current, options)
     end
 
-    def past_month(options={})
-      between_times(Time.zone.now - 1.month, Time.zone.now, options)
+    def past_month(options = {})
+      between_times(Time.current - 1.month, Time.current, options)
     end
 
-    def past_year(options={})
-      between_times(Time.zone.now - 1.year, Time.zone.now, options)
+    def past_year(options = {})
+      between_times(Time.current - 1.year, Time.current, options)
     end
 
-    def next_day(options={})
-      between_times(Time.zone.now, Time.zone.now + 1.day, options)
+    def next_day(options = {})
+      between_times(Time.current, Time.current + 1.day, options)
     end
 
-    def next_week(options={})
-      between_times(Time.zone.now, Time.zone.now  + 1.week, options)
+    def next_week(options = {})
+      between_times(Time.current, Time.current  + 1.week, options)
     end
 
-    def next_fortnight(options={})
-      between_times(Time.zone.now, Time.zone.now + 2.weeks, options)
+    def next_fortnight(options = {})
+      between_times(Time.current, Time.current + 2.weeks, options)
     end
 
-    def next_month(options={})
-      between_times(Time.zone.now, Time.zone.now + 1.month, options)
+    def next_month(options = {})
+      between_times(Time.current, Time.current + 1.month, options)
     end
 
-    def next_year(options={})
-      between_times(Time.zone.now, Time.zone.now + 1.year, options)
+    def next_year(options = {})
+      between_times(Time.current, Time.current + 1.year, options)
     end
   end
 end

data/lib/by_star/directional.rb

@@ -4,20 +4,18 @@ module ByStar
 
     def before(*args)
       with_by_star_options(*args) do |time, options|
-        scope = by_star_scope(options)
         field = by_star_start_field(options)
         time = ByStar::Normalization.time(time)
-        by_star_before_query(scope, field, time)
+        by_star_before_query(self, field, time)
       end
     end
     alias_method :before_now, :before
 
     def after(*args)
       with_by_star_options(*args) do |time, options|
-        scope = by_star_scope(options)
         field = by_star_start_field(options)
         time = ByStar::Normalization.time(time)
-        by_star_after_query(scope, field, time)
+        by_star_after_query(self, field, time)
       end
     end
     alias_method :after_now, :after

data/lib/by_star/kernel/date.rb

@@ -3,15 +3,6 @@ module ByStar
   module Kernel
 
     module Date
-      extend ActiveSupport::Concern
-
-      included do
-
-        # Shim to alias Rails 3 #to_time_in_current_zone to Rails 4 name #in_time_zone
-        if method_defined?(:to_time_in_current_zone) && !method_defined?(:in_time_zone)
-          alias_method :in_time_zone, :to_time_in_current_zone
-        end
-      end
 
       # A "Weekend" is defined as beginning of Saturday to end of Sunday.
       # The weekend for a given date will be the the next weekend if the day Mon-Thurs,

data/lib/by_star/kernel/in_time_zone.rb

@@ -0,0 +1,20 @@
+module ByStar
+
+  module Kernel
+
+    module InTimeZone
+      extend ActiveSupport::Concern
+
+      included do
+        if method_defined?(:to_time_in_current_zone) && !method_defined?(:in_time_zone)
+          alias_method :in_time_zone, :to_time_in_current_zone
+        end
+      end
+    end
+  end
+end
+
+::Date.__send__(:include, ByStar::Kernel::InTimeZone)
+::Time.__send__(:include, ByStar::Kernel::InTimeZone)
+::DateTime.__send__(:include, ByStar::Kernel::InTimeZone)
+::ActiveSupport::TimeWithZone.__send__(:include, ByStar::Kernel::InTimeZone)

data/lib/by_star/normalization.rb

@@ -6,33 +6,22 @@ module ByStar
 
     class << self
 
-      def time(value)
-        case value
-          when String   then time_string(value)
-          when DateTime then value.to_time
-          when Date     then value.in_time_zone
-          else value
-        end
-      end
-
-      def time_string(value)
-        defined?(Chronic) ? time_string_chronic(value) : time_string_fallback(value)
+      def date(value)
+        value = parse_time(value) if value.is_a?(String)
+        value = value.try(:in_time_zone) unless value.is_a?(Date)
+        value.try(:to_date)
       end
 
-      def time_string_chronic(value)
-        Chronic.time_class = Time.zone
-        Chronic.parse(value) || raise(ByStar::ParseError, "Chronic could not parse String #{value.inspect}")
-      end
-
-      def time_string_fallback(value)
-        Time.zone.parse(value) || raise(ByStar::ParseError, "Cannot parse String #{value.inspect}")
+      def time(value)
+        value = parse_time(value) if value.is_a?(String)
+        value.try(:in_time_zone)
       end
 
       def week(value, options={})
         value = try_string_to_int(value)
         case value
           when Integer then week_integer(value, options)
-          else time(value)
+          else date(value)
         end
       end
 
@@ -55,7 +44,7 @@ module ByStar
         value = try_string_to_int(value)
         case value
           when Integer then fortnight_integer(value, options)
-          else time(value)
+          else date(value)
         end
       end
 
@@ -69,7 +58,7 @@ module ByStar
         value = try_string_to_int(value)
         case value
           when Integer then quarter_integer(value, options)
-          else time(value)
+          else date(value)
         end
       end
 
@@ -83,7 +72,7 @@ module ByStar
         value = try_string_to_int(value)
         case value
           when Integer, String then month_integer(value, options)
-          else time(value)
+          else date(value)
         end
       end
 
@@ -98,7 +87,7 @@ module ByStar
         value = try_string_to_int(value)
         case value
           when Integer then year_integer(value)
-          else time(value)
+          else date(value)
         end
       end
 
@@ -122,6 +111,46 @@ module ByStar
       rescue
         value
       end
+
+      def time_in_units(seconds)
+        days = seconds / 1.day
+        time = Time.at(seconds).utc
+        { days: days, hour: time.hour, min: time.min, sec: time.sec }
+      end
+
+      def apply_offset_start(time, offset)
+        units = time_in_units(offset)
+        time += units.delete(:days).days
+        time.change(units)
+      end
+
+      def apply_offset_end(time, offset)
+        units = time_in_units(offset)
+        time += units.delete(:days).days
+        (time + 1.day).change(units) - 1.second
+      end
+
+      def extract_range(args)
+        case args[0]
+        when Array, Range then [args[0].first, args[0].last]
+        else args[0..1]
+        end
+      end
+
+      private
+
+      def parse_time(value)
+        defined?(Chronic) ? parse_time_chronic(value) : parse_time_fallback(value)
+      end
+
+      def parse_time_chronic(value)
+        Chronic.time_class = Time.zone
+        Chronic.parse(value) || raise(ByStar::ParseError, "Chronic could not parse String #{value.inspect}")
+      end
+
+      def parse_time_fallback(value)
+        Time.zone.parse(value) || raise(ByStar::ParseError, "Cannot parse String #{value.inspect}")
+      end
     end
   end
 end

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

@@ -19,8 +19,22 @@ module ByStar
         scope.where("#{start_field} >= ? AND #{start_field} <= ? AND #{end_field} >= ? AND #{end_field} <= ?", start_time, end_time, start_time, end_time)
       end
 
-      def by_star_span_overlap_query(scope, start_field, end_field, start_time, end_time, options)
-        scope.where("#{end_field} > ? AND #{start_field} < ?", start_time, end_time)
+      def by_star_span_loose_query(scope, start_field, end_field, start_time, end_time, options)
+        index_scope = by_star_eval_index_scope(start_time, end_time, options)
+        scope = scope.where("#{end_field} > ? AND #{start_field} < ?", start_time, end_time)
+        scope = scope.where("#{start_field} >= ?", index_scope) if index_scope
+        scope
+      end
+
+      def by_star_point_overlap_query(scope, field, time)
+        scope.where("#{field} = ?", time)
+      end
+
+      def by_star_span_overlap_query(scope, start_field, end_field, time, options)
+        index_scope = by_star_eval_index_scope(time, time, options)
+        scope = scope.where("#{end_field} > ? AND #{start_field} <= ?", time, time)
+        scope = scope.where("#{start_field} >= ?", index_scope) if index_scope
+        scope
       end
 
       def by_star_before_query(scope, field, time)
@@ -37,25 +51,25 @@ module ByStar
 
       def oldest_query(options={})
         field = by_star_start_field(options)
-        by_star_scope(options).reorder("#{field} ASC").first
+        reorder("#{field} ASC").first
       end
 
       def newest_query(options={})
         field = by_star_start_field(options)
-        by_star_scope(options).reorder("#{field} DESC").first
+        reorder("#{field} DESC").first
       end
     end
 
     def previous(options={})
       field = self.class.by_star_start_field(options)
       value = self.send(field.split(".").last)
-      self.class.by_star_scope(options.merge(scope_args: self)).where("#{field} < ?", value).reorder("#{field} DESC").first
+      self.class.where("#{field} < ?", value).reorder("#{field} DESC").first
     end
 
     def next(options={})
       field = self.class.by_star_start_field(options)
       value = self.send(field.split(".").last)
-      self.class.by_star_scope(options.merge(scope_args: self)).where("#{field} > ?", value).reorder("#{field} ASC").first
+      self.class.where("#{field} > ?", value).reorder("#{field} ASC").first
     end
   end
 end

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

@@ -36,8 +36,22 @@ module Mongoid
         scope.where(start_field => range).where(end_field => range)
       end
 
-      def by_star_span_overlap_query(scope, start_field, end_field, start_time, end_time, options)
-        scope.gt(end_field => start_time).lt(start_field => end_time)
+      def by_star_span_loose_query(scope, start_field, end_field, start_time, end_time, options)
+        index_scope = by_star_eval_index_scope(start_time, end_time, options)
+        scope = scope.gt(end_field => start_time).lt(start_field => end_time)
+        scope = scope.gte(start_field => index_scope) if index_scope
+        scope
+      end
+
+      def by_star_point_overlap_query(scope, field, time)
+        scope.where(field => time)
+      end
+
+      def by_star_span_overlap_query(scope, start_field, end_field, time, options)
+        index_scope = by_star_eval_index_scope(time, time, options)
+        scope = scope.gt(end_field => time).lte(start_field => time)
+        scope = scope.gte(start_field => index_scope) if index_scope
+        scope
       end
 
       def by_star_before_query(scope, field, time)
@@ -54,23 +68,23 @@ module Mongoid
 
       def oldest_query(options={})
         field = by_star_start_field(options)
-        by_star_scope(options).all.reorder(field => :asc).first
+        all.reorder(field => :asc).first
       end
 
       def newest_query(options={})
         field = by_star_start_field(options)
-        by_star_scope(options).all.reorder(field => :desc).first
+        all.reorder(field => :desc).first
       end
     end
 
     def previous(options={})
       field = self.class.by_star_start_field(options)
-      self.class.by_star_scope(options.merge(scope_args: self)).lt(field => self.send(field)).reorder(field => :desc).first
+      self.class.lt(field => self.send(field)).reorder(field => :desc).first
     end
 
     def next(options={})
       field = self.class.by_star_start_field(options)
-      self.class.by_star_scope(options.merge(scope_args: self)).gt(field => self.send(field)).reorder(field => :asc).first
+      self.class.gt(field => self.send(field)).reorder(field => :asc).first
     end
   end
 end

data/lib/by_star/version.rb

@@ -1,3 +1,3 @@
 module ByStar
-  VERSION = '3.0.0'
+  VERSION = '4.0.0'
 end

data/lib/by_star.rb

@@ -1,3 +1,4 @@
+require 'by_star/kernel/in_time_zone'
 require 'by_star/kernel/time'
 require 'by_star/kernel/date'
 require 'by_star/normalization'

data/spec/database.yml

@@ -5,7 +5,7 @@ sqlite:
 postgres:
   adapter: postgresql
   database: by_star_test
-  username: postgres
+  username: <%= ENV.fetch("USER") || "postgres" %>
   min_messages: warning
 
 mysql:

data/spec/fixtures/active_record/models.rb

@@ -2,11 +2,11 @@ class Post < ActiveRecord::Base
 end
 
 class Appointment < ActiveRecord::Base
-  by_star_field scope: ->{ where(day_of_month: 1) }
+  by_star_field index_scope: ->(start){ start - 5.days }
 end
 
 class Event < ActiveRecord::Base
   by_star_field :start_time, :end_time, offset: 3.hours
 
-  default_scope ->{ order(day_of_month: :asc) }
+  default_scope ->{ order('day_of_month ASC') }
 end

data/spec/fixtures/mongoid/models.rb

@@ -13,7 +13,7 @@ class Appointment
 
   field :day_of_month,        type: Integer
 
-  by_star_field scope: ->{ where(day_of_month: 1) }
+  by_star_field index_scope: ->(start){ start - 5.days }
 end
 
 class Event

data/spec/fixtures/shared/seeds.rb

@@ -24,3 +24,13 @@
   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
+
+# Sydney timezone specific records
+%w(
+  2020-04-05
+  2020-10-04
+).map{|d| Date.parse(d) }.each do |d|
+  [1, 4, 5, 10].each do |h|
+    Event.create!(start_time: d + h.hour, end_time: d + h.hour + 30.minutes, created_at: Date.parse('2011-01-01').in_time_zone)
+  end
+end

data/spec/gemfiles/Gemfile.rails

@@ -0,0 +1,5 @@
+source 'http://rubygems.org'
+
+gemspec path: '../../'
+
+gem 'activerecord', github: 'rails', branch: "main"

data/spec/gemfiles/Gemfile.rails32

@@ -0,0 +1,7 @@
+source 'http://rubygems.org'
+
+gemspec path: '../../'
+
+gem 'activerecord', '~> 3.2.0'
+gem 'pg',           '~> 0.11'
+gem 'mongoid'

data/spec/gemfiles/Gemfile.rails40

@@ -4,4 +4,4 @@ gemspec path: '../../'
 
 gem 'activerecord', '~> 4.0.0'
 gem 'pg',           '~> 0.11'
-gem 'mongoid',      '~> 4.0.0'
+gem 'mongoid'

data/spec/gemfiles/Gemfile.rails41

@@ -4,4 +4,4 @@ gemspec path: '../../'
 
 gem 'activerecord', '~> 4.1.0'
 gem 'pg',           '~> 0.11'
-gem 'mongoid',      '~> 4.0.0'
+gem 'mongoid'

data/spec/gemfiles/Gemfile.rails42

@@ -2,6 +2,6 @@ source 'http://rubygems.org'
 
 gemspec path: '../../'
 
-gem 'mongoid',      '~> 4.0.0'
-gem 'pg',           '~> 0.15'
 gem 'activerecord', '~> 4.2.0'
+gem 'pg',           '~> 0.15'
+gem 'mongoid'