Skip to content
This repository
tag: v2.0.4
Fetching contributors…

Cannot retrieve contributors at this time

file 224 lines (193 sloc) 9.004 kb
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
module ActiveSupport #:nodoc:
  module CoreExtensions #:nodoc:
    module Time #:nodoc:
      # Enables the use of time calculations within Time itself
      module Calculations
        def self.included(base) #:nodoc:
          base.extend ClassMethods

          base.class_eval do
            alias_method :plus_without_duration, :+
            alias_method :+, :plus_with_duration
            alias_method :minus_without_duration, :-
            alias_method :-, :minus_with_duration
          end
        end

        module ClassMethods
          # Return the number of days in the given month. If a year is given,
          # February will return the correct number of days for leap years.
          # Otherwise, this method will always report February as having 28
          # days.
          def days_in_month(month, year=nil)
            if month == 2
              !year.nil? && (year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0)) ? 29 : 28
            elsif month <= 7
              month % 2 == 0 ? 30 : 31
            else
              month % 2 == 0 ? 31 : 30
            end
          end

          # Returns a new Time if requested year can be accommodated by Ruby's Time class
          # (i.e., if year is within either 1970..2038 or 1902..2038, depending on system architecture);
          # otherwise returns a DateTime
          def time_with_datetime_fallback(utc_or_local, year, month=1, day=1, hour=0, min=0, sec=0, usec=0)
            ::Time.send(utc_or_local, year, month, day, hour, min, sec, usec)
          rescue
            offset = utc_or_local.to_sym == :local ? ::DateTime.local_offset : 0
            ::DateTime.civil(year, month, day, hour, min, sec, offset)
          end

          # wraps class method time_with_datetime_fallback with utc_or_local == :utc
          def utc_time(*args)
            time_with_datetime_fallback(:utc, *args)
          end

          # wraps class method time_with_datetime_fallback with utc_or_local == :local
          def local_time(*args)
            time_with_datetime_fallback(:local, *args)
          end
        end

        # Seconds since midnight: Time.now.seconds_since_midnight
        def seconds_since_midnight
          self.to_i - self.change(:hour => 0).to_i + (self.usec/1.0e+6)
        end

        # Returns a new Time where one or more of the elements have been changed according to the +options+ parameter. The time options
        # (hour, minute, sec, usec) reset cascadingly, so if only the hour is passed, then minute, sec, and usec is set to 0. If the hour and
        # minute is passed, then sec and usec is set to 0.
        def change(options)
          ::Time.send(
            self.utc? ? :utc_time : :local_time,
            options[:year] || self.year,
            options[:month] || self.month,
            options[:day] || self.day,
            options[:hour] || self.hour,
            options[:min] || (options[:hour] ? 0 : self.min),
            options[:sec] || ((options[:hour] || options[:min]) ? 0 : self.sec),
            options[:usec] || ((options[:hour] || options[:min] || options[:sec]) ? 0 : self.usec)
          )
        end

        # Uses Date to provide precise Time calculations for years, months, and days. The +options+ parameter takes a hash with
        # any of these keys: :years, :months, :weeks, :days, :hours, :minutes, :seconds.
        def advance(options)
          d = to_date.advance(options)
          time_advanced_by_date = change(:year => d.year, :month => d.month, :day => d.day)
          seconds_to_advance = (options[:seconds] || 0) + (options[:minutes] || 0) * 60 + (options[:hours] || 0) * 3600
          seconds_to_advance == 0 ? time_advanced_by_date : time_advanced_by_date.since(seconds_to_advance)
        end

        # Returns a new Time representing the time a number of seconds ago, this is basically a wrapper around the Numeric extension
        # Do not use this method in combination with x.months, use months_ago instead!
        def ago(seconds)
          self.since(-seconds)
        end

        # Returns a new Time representing the time a number of seconds since the instance time, this is basically a wrapper around
        # the Numeric extension. Do not use this method in combination with x.months, use months_since instead!
        def since(seconds)
          initial_dst = self.dst? ? 1 : 0
          f = seconds.since(self)
          final_dst = f.dst? ? 1 : 0
          (seconds.abs >= 86400 && initial_dst != final_dst) ? f + (initial_dst - final_dst).hours : f
        rescue
          self.to_datetime.since(seconds)
        end
        alias :in :since

        # Returns a new Time representing the time a number of specified months ago
        def months_ago(months)
          advance(:months => -months)
        end

        # Returns a new Time representing the time a number of specified months in the future
        def months_since(months)
          advance(:months => months)
        end

        # Returns a new Time representing the time a number of specified years ago
        def years_ago(years)
          advance(:years => -years)
        end

        # Returns a new Time representing the time a number of specified years in the future
        def years_since(years)
          advance(:years => years)
        end

        # Short-hand for years_ago(1)
        def last_year
          years_ago(1)
        end

        # Short-hand for years_since(1)
        def next_year
          years_since(1)
        end


        # Short-hand for months_ago(1)
        def last_month
          months_ago(1)
        end

        # Short-hand for months_since(1)
        def next_month
          months_since(1)
        end

        # Returns a new Time representing the "start" of this week (Monday, 0:00)
        def beginning_of_week
          days_to_monday = self.wday!=0 ? self.wday-1 : 6
          (self - days_to_monday.days).midnight
        end
        alias :monday :beginning_of_week
        alias :at_beginning_of_week :beginning_of_week

        # Returns a new Time representing the start of the given day in next week (default is Monday).
        def next_week(day = :monday)
          days_into_week = { :monday => 0, :tuesday => 1, :wednesday => 2, :thursday => 3, :friday => 4, :saturday => 5, :sunday => 6}
          since(1.week).beginning_of_week.since(days_into_week[day].day).change(:hour => 0)
        end

        # Returns a new Time representing the start of the day (0:00)
        def beginning_of_day
          (self - self.seconds_since_midnight).change(:usec => 0)
        end
        alias :midnight :beginning_of_day
        alias :at_midnight :beginning_of_day
        alias :at_beginning_of_day :beginning_of_day

        # Returns a new Time representing the end of the day (23:59:59)
        def end_of_day
          change(:hour => 23, :min => 59, :sec => 59)
        end

        # Returns a new Time representing the start of the month (1st of the month, 0:00)
        def beginning_of_month
          #self - ((self.mday-1).days + self.seconds_since_midnight)
          change(:day => 1,:hour => 0, :min => 0, :sec => 0, :usec => 0)
        end
        alias :at_beginning_of_month :beginning_of_month

        # Returns a new Time representing the end of the month (last day of the month, 0:00)
        def end_of_month
          #self - ((self.mday-1).days + self.seconds_since_midnight)
          last_day = ::Time.days_in_month( self.month, self.year )
          change(:day => last_day, :hour => 23, :min => 59, :sec => 59, :usec => 0)
        end
        alias :at_end_of_month :end_of_month

        # Returns a new Time representing the start of the quarter (1st of january, april, july, october, 0:00)
        def beginning_of_quarter
          beginning_of_month.change(:month => [10, 7, 4, 1].detect { |m| m <= self.month })
        end
        alias :at_beginning_of_quarter :beginning_of_quarter

        # Returns a new Time representing the start of the year (1st of january, 0:00)
        def beginning_of_year
          change(:month => 1,:day => 1,:hour => 0, :min => 0, :sec => 0, :usec => 0)
        end
        alias :at_beginning_of_year :beginning_of_year

        # Convenience method which returns a new Time representing the time 1 day ago
        def yesterday
          self.ago(1.day)
        end

        # Convenience method which returns a new Time representing the time 1 day since the instance time
        def tomorrow
          self.since(1.day)
        end

        def plus_with_duration(other) #:nodoc:
          if ActiveSupport::Duration === other
            other.since(self)
          else
            plus_without_duration(other)
          end
        end

        def minus_with_duration(other) #:nodoc:
          if ActiveSupport::Duration === other
            other.until(self)
          else
            minus_without_duration(other)
          end
        end
      end
    end
  end
end
Something went wrong with that request. Please try again.