by_star 2.2.0 → 4.0.0

data/lib/by_star/directional.rb

@@ -1,21 +1,35 @@
-module ByStar
-
-  module Directional
-
-    def before(*args)
-      with_by_star_options(*args) do |time, options|
-        time = ByStar::Normalization.time(time)
-        before_query(time, options)
-      end
-    end
-    alias_method :before_now, :before
-
-    def after(*args)
-      with_by_star_options(*args) do |time, options|
-        time = ByStar::Normalization.time(time)
-        after_query(time, options)
-      end
-    end
-    alias_method :after_now, :after
-  end
-end
+module ByStar
+
+  module Directional
+
+    def before(*args)
+      with_by_star_options(*args) do |time, options|
+        field = by_star_start_field(options)
+        time = ByStar::Normalization.time(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|
+        field = by_star_start_field(options)
+        time = ByStar::Normalization.time(time)
+        by_star_after_query(self, field, time)
+      end
+    end
+    alias_method :after_now, :after
+
+    def oldest(*args)
+      with_by_star_options(*args) do |time, options|
+        oldest_query(options)
+      end
+    end
+
+    def newest(*args)
+      with_by_star_options(*args) do |time, options|
+        newest_query(options)
+      end
+    end
+  end
+end

data/lib/by_star/kernel/date.rb

@@ -0,0 +1,41 @@
+module ByStar
+
+  module Kernel
+
+    module Date
+
+      # 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,
+      # otherwise the current weekend if the day is Fri-Sun.
+      def beginning_of_weekend
+        beginning_of_week(:monday).advance(days: 5)
+      end
+
+      def end_of_weekend
+        beginning_of_weekend + 1
+      end
+
+      # 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 + 14 * ((self - beginning_of_year) / 14).to_i
+      end
+
+      def end_of_fortnight
+        beginning_of_fortnight + 13
+      end
+
+      # 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)
+      end
+
+      def end_of_calendar_month(*args)
+        end_of_month.end_of_week(*args)
+      end
+    end
+  end
+end
+
+::Date.__send__(:include, ByStar::Kernel::Date)

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/{kernel.rb → kernel/time.rb}

@@ -1,41 +1,41 @@
-module ByStar
-
-  module Kernel
-
-    module Time
-
-      # A "Weekend" is defined as the 60-hour period from 15:00 Friday to 03:00 Monday.
-      # The weekend for a given date will be the the next weekend if the day Mon-Thurs,
-      # otherwise the current weekend if the day is Fri-Sun.
-      def beginning_of_weekend
-        beginning_of_week(:monday).advance(:days => 4) + 15.hours
-      end
-
-      def end_of_weekend
-        (beginning_of_weekend + 59.hours).end_of_hour
-      end
-
-      # 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.to_date + 14 * ((self - beginning_of_year) / 2.weeks).to_i).beginning_of_day
-      end
-
-      def end_of_fortnight
-        (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 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)
-      end
-
-      def end_of_calendar_month(*args)
-        end_of_month.end_of_week(*args)
-      end
-    end
-  end
-end
-
-::Time.__send__(:include, ByStar::Kernel::Time)
+module ByStar
+
+  module Kernel
+
+    module Time
+
+      # 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,
+      # otherwise the current weekend if the day is Fri-Sun.
+      def beginning_of_weekend
+        beginning_of_week(:monday).advance(days: 5)
+      end
+
+      def end_of_weekend
+        (beginning_of_weekend + 47.hours).end_of_hour
+      end
+
+      # 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 + 1.fortnight * ((self - beginning_of_year) / 1.fortnight).to_i).beginning_of_day
+      end
+
+      def end_of_fortnight
+        (beginning_of_fortnight + 13.days).end_of_day
+      end
+
+      # 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)
+      end
+
+      def end_of_calendar_month(*args)
+        end_of_month.end_of_week(*args)
+      end
+    end
+  end
+end
+
+::Time.__send__(:include, ByStar::Kernel::Time)

data/lib/by_star/normalization.rb

@@ -1,118 +1,156 @@
-module ByStar
-
-  class ParseError < StandardError; end
-
-  module Normalization
-
-    class << self
-
-      def time(value)
-        case value
-          when String then time_string(value)
-          when DateTime then value.to_time
-          when Date then value.to_time_in_current_zone
-          else value
-        end
-      end
-
-      def time_string(value)
-        defined?(Chronic) ? time_string_chronic(value) : time_string_fallback(value)
-      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}")
-      end
-
-      def week(value, options={})
-        value = try_string_to_int(value)
-        case value
-          when Fixnum then week_fixnum(value, options)
-          else time(value)
-        end
-      end
-
-      def week_fixnum(value, options={})
-        raise ParseError, 'Week number must be between 0 and 52' unless value.in?(0..52)
-        time = Time.zone.local(options[:year] || Time.zone.now.year)
-        time.beginning_of_year + value.to_i.weeks
-      end
-
-      def fortnight(value, options={})
-        value = try_string_to_int(value)
-        case value
-          when Fixnum then fortnight_fixnum(value, options)
-          else time(value)
-        end
-      end
-
-      def fortnight_fixnum(value, options={})
-        raise ParseError, 'Fortnight number must be between 0 and 26' unless value.in?(0..26)
-        time = Time.zone.local(options[:year] || Time.zone.now.year)
-        time + (value * 2).weeks
-      end
-
-      def quarter(value, options={})
-        value = try_string_to_int(value)
-        case value
-          when Fixnum then quarter_fixnum(value, options)
-          else time(value)
-        end
-      end
-
-      def quarter_fixnum(value, options={})
-        raise ParseError, 'Quarter number must be between 1 and 4' unless value.in?(1..4)
-        time = Time.zone.local(options[:year] || Time.zone.now.year)
-        time.beginning_of_year + ((value - 1) * 3).months
-      end
-
-      def month(value, options={})
-        value = try_string_to_int(value)
-        case value
-          when Fixnum, String then month_fixnum(value, options)
-          else time(value)
-        end
-      end
-
-      def month_fixnum(value, options={})
-        year = options[:year] || Time.zone.now.year
-        Time.zone.parse "#{year}-#{value}-01"
-      rescue
-        raise ParseError, 'Month must be a number between 1 and 12 or a month name'
-      end
-
-      def year(value, options={})
-        value = try_string_to_int(value)
-        case value
-          when Fixnum then year_fixnum(value)
-          else time(value)
-        end
-      end
-
-      def year_fixnum(value)
-        Time.zone.local(extrapolate_year(value))
-      end
-
-      def extrapolate_year(value)
-        case value.to_i
-          when 0..69
-            2000 + value
-          when 70..99
-            1900 + value
-          else
-            value.to_i
-        end
-      end
-
-      def try_string_to_int(value)
-        value.is_a?(String) ? Integer(value) : value
-      rescue
-        value
-      end
-    end
-  end
-end
+module ByStar
+
+  class ParseError < StandardError; end
+
+  module Normalization
+
+    class << self
+
+      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(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 date(value)
+        end
+      end
+
+      def week_integer(value, options={})
+        raise ParseError, 'Week number must be between 0 and 52' unless value.in?(0..52)
+        time = Time.zone.local(options[:year] || Time.zone.now.year)
+        time.beginning_of_year + value.to_i.weeks
+      end
+
+      def cweek(value, options={})
+        _value = value
+        if _value.is_a?(Integer)
+          raise ParseError, 'cweek number must be between 1 and 53' unless value.in?(1..53)
+          _value -= 1
+        end
+        week(_value, options)
+      end
+
+      def fortnight(value, options={})
+        value = try_string_to_int(value)
+        case value
+          when Integer then fortnight_integer(value, options)
+          else date(value)
+        end
+      end
+
+      def fortnight_integer(value, options={})
+        raise ParseError, 'Fortnight number must be between 0 and 26' unless value.in?(0..26)
+        time = Time.zone.local(options[:year] || Time.zone.now.year)
+        time + (value * 2).weeks
+      end
+
+      def quarter(value, options={})
+        value = try_string_to_int(value)
+        case value
+          when Integer then quarter_integer(value, options)
+          else date(value)
+        end
+      end
+
+      def quarter_integer(value, options={})
+        raise ParseError, 'Quarter number must be between 1 and 4' unless value.in?(1..4)
+        time = Time.zone.local(options[:year] || Time.zone.now.year)
+        time.beginning_of_year + ((value - 1) * 3).months
+      end
+
+      def month(value, options={})
+        value = try_string_to_int(value)
+        case value
+          when Integer, String then month_integer(value, options)
+          else date(value)
+        end
+      end
+
+      def month_integer(value, options={})
+        year = options[:year] || Time.zone.now.year
+        Time.zone.parse "#{year}-#{value}-01"
+      rescue
+        raise ParseError, 'Month must be a number between 1 and 12 or a month name'
+      end
+
+      def year(value, options={})
+        value = try_string_to_int(value)
+        case value
+          when Integer then year_integer(value)
+          else date(value)
+        end
+      end
+
+      def year_integer(value)
+        Time.zone.local(extrapolate_year(value))
+      end
+
+      def extrapolate_year(value)
+        case value.to_i
+          when 0..69
+            2000 + value
+          when 70..99
+            1900 + value
+          else
+            value.to_i
+        end
+      end
+
+      def try_string_to_int(value)
+        value.is_a?(String) ? Integer(value) : value
+      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

@@ -1,59 +1,75 @@
-module ByStar
-  module ActiveRecord
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      include ::ByStar::Base
-
-      # Returns all records between a given start and finish time.
-      #
-      # Currently only supports Time objects.
-      def between_times_query(start, finish, options={})
-        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
-          scope.where("#{end_field} > ? AND #{start_field} < ?", start, finish)
-        end
-        scope = scope.order(options[:order]) if options[:order]
-        scope
-      end
-
-      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
-
-      def by_star_default_field
-        "#{self.table_name}.created_at"
-      end
-
-      def before_query(time, options={})
-        field = by_star_start_field(options)
-        by_star_scope(options).where("#{field} <= ?", time)
-      end
-
-      def after_query(time, options={})
-        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.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.by_star_scope(options).where("#{field} > ?", value).reorder("#{field} ASC").first
-    end
-  end
-end
+module ByStar
+  module ActiveRecord
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      include ::ByStar::Base
+
+      protected
+
+      def by_star_default_field
+        "#{self.table_name}.created_at"
+      end
+
+      def by_star_point_query(scope, field, start_time, end_time)
+        scope.where("#{field} >= ? AND #{field} <= ?", start_time, end_time)
+      end
+
+      def by_star_span_strict_query(scope, start_field, end_field, start_time, end_time)
+        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_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)
+        scope.where("#{field} <= ?", time)
+      end
+
+      def by_star_after_query(scope, field, time)
+        scope.where("#{field} >= ?", time)
+      end
+
+      def by_star_order(scope, order)
+        scope.order(order)
+      end
+
+      def oldest_query(options={})
+        field = by_star_start_field(options)
+        reorder("#{field} ASC").first
+      end
+
+      def newest_query(options={})
+        field = by_star_start_field(options)
+        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.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.where("#{field} > ?", value).reorder("#{field} ASC").first
+    end
+  end
+end