lazy_record 0.2.1 → 0.2.2

data/vendor/bundle/gems/activesupport-5.0.2/lib/active_support/core_ext/string/inquiry.rb

@@ -1,13 +0,0 @@
-require 'active_support/string_inquirer'
-
-class String
-  # Wraps the current string in the <tt>ActiveSupport::StringInquirer</tt> class,
-  # which gives you a prettier way to test for equality.
-  #
-  #   env = 'production'.inquiry
-  #   env.production?  # => true
-  #   env.development? # => false
-  def inquiry
-    ActiveSupport::StringInquirer.new(self)
-  end
-end

data/vendor/bundle/gems/activesupport-5.0.2/lib/active_support/core_ext/string/multibyte.rb

@@ -1,53 +0,0 @@
-require 'active_support/multibyte'
-
-class String
-  # == Multibyte proxy
-  #
-  # +mb_chars+ is a multibyte safe proxy for string methods.
-  #
-  # It creates and returns an instance of the ActiveSupport::Multibyte::Chars class which
-  # encapsulates the original string. A Unicode safe version of all the String methods are defined on this proxy
-  # class. If the proxy class doesn't respond to a certain method, it's forwarded to the encapsulated string.
-  #
-  #   >> "lj".upcase
-  #   => "lj"
-  #   >> "lj".mb_chars.upcase.to_s
-  #   => "LJ"
-  #
-  # == Method chaining
-  #
-  # All the methods on the Chars proxy which normally return a string will return a Chars object. This allows
-  # method chaining on the result of any of these methods.
-  #
-  #   name.mb_chars.reverse.length # => 12
-  #
-  # == Interoperability and configuration
-  #
-  # The Chars object tries to be as interchangeable with String objects as possible: sorting and comparing between
-  # String and Char work like expected. The bang! methods change the internal string representation in the Chars
-  # object. Interoperability problems can be resolved easily with a +to_s+ call.
-  #
-  # For more information about the methods defined on the Chars proxy see ActiveSupport::Multibyte::Chars. For
-  # information about how to change the default Multibyte behavior see ActiveSupport::Multibyte.
-  def mb_chars
-    ActiveSupport::Multibyte.proxy_class.new(self)
-  end
-
-  # Returns +true+ if string has utf_8 encoding.
-  #
-  #   utf_8_str = "some string".encode "UTF-8"
-  #   iso_str = "some string".encode "ISO-8859-1"
-  #
-  #   utf_8_str.is_utf8? # => true
-  #   iso_str.is_utf8?   # => false
-  def is_utf8?
-    case encoding
-    when Encoding::UTF_8
-      valid_encoding?
-    when Encoding::ASCII_8BIT, Encoding::US_ASCII
-      dup.force_encoding(Encoding::UTF_8).valid_encoding?
-    else
-      false
-    end
-  end
-end

data/vendor/bundle/gems/activesupport-5.0.2/lib/active_support/core_ext/string/output_safety.rb

@@ -1,260 +0,0 @@
-require 'erb'
-require 'active_support/core_ext/kernel/singleton_class'
-
-class ERB
-  module Util
-    HTML_ESCAPE = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;', "'" => '&#39;' }
-    JSON_ESCAPE = { '&' => '\u0026', '>' => '\u003e', '<' => '\u003c', "\u2028" => '\u2028', "\u2029" => '\u2029' }
-    HTML_ESCAPE_ONCE_REGEXP = /["><']|&(?!([a-zA-Z]+|(#\d+)|(#[xX][\dA-Fa-f]+));)/
-    JSON_ESCAPE_REGEXP = /[\u2028\u2029&><]/u
-
-    # A utility method for escaping HTML tag characters.
-    # This method is also aliased as <tt>h</tt>.
-    #
-    # In your ERB templates, use this method to escape any unsafe content. For example:
-    #   <%= h @person.name %>
-    #
-    #   puts html_escape('is a > 0 & a < 10?')
-    #   # => is a &gt; 0 &amp; a &lt; 10?
-    def html_escape(s)
-      unwrapped_html_escape(s).html_safe
-    end
-
-    # Aliasing twice issues a warning "discarding old...". Remove first to avoid it.
-    remove_method(:h)
-    alias h html_escape
-
-    module_function :h
-
-    singleton_class.send(:remove_method, :html_escape)
-    module_function :html_escape
-
-    # HTML escapes strings but doesn't wrap them with an ActiveSupport::SafeBuffer.
-    # This method is not for public consumption! Seriously!
-    def unwrapped_html_escape(s) # :nodoc:
-      s = s.to_s
-      if s.html_safe?
-        s
-      else
-        CGI.escapeHTML(ActiveSupport::Multibyte::Unicode.tidy_bytes(s))
-      end
-    end
-    module_function :unwrapped_html_escape
-
-    # A utility method for escaping HTML without affecting existing escaped entities.
-    #
-    #   html_escape_once('1 < 2 &amp; 3')
-    #   # => "1 &lt; 2 &amp; 3"
-    #
-    #   html_escape_once('&lt;&lt; Accept & Checkout')
-    #   # => "&lt;&lt; Accept &amp; Checkout"
-    def html_escape_once(s)
-      result = ActiveSupport::Multibyte::Unicode.tidy_bytes(s.to_s).gsub(HTML_ESCAPE_ONCE_REGEXP, HTML_ESCAPE)
-      s.html_safe? ? result.html_safe : result
-    end
-
-    module_function :html_escape_once
-
-    # A utility method for escaping HTML entities in JSON strings. Specifically, the
-    # &, > and < characters are replaced with their equivalent unicode escaped form -
-    # \u0026, \u003e, and \u003c. The Unicode sequences \u2028 and \u2029 are also
-    # escaped as they are treated as newline characters in some JavaScript engines.
-    # These sequences have identical meaning as the original characters inside the
-    # context of a JSON string, so assuming the input is a valid and well-formed
-    # JSON value, the output will have equivalent meaning when parsed:
-    #
-    #   json = JSON.generate({ name: "</script><script>alert('PWNED!!!')</script>"})
-    #   # => "{\"name\":\"</script><script>alert('PWNED!!!')</script>\"}"
-    #
-    #   json_escape(json)
-    #   # => "{\"name\":\"\\u003C/script\\u003E\\u003Cscript\\u003Ealert('PWNED!!!')\\u003C/script\\u003E\"}"
-    #
-    #   JSON.parse(json) == JSON.parse(json_escape(json))
-    #   # => true
-    #
-    # The intended use case for this method is to escape JSON strings before including
-    # them inside a script tag to avoid XSS vulnerability:
-    #
-    #   <script>
-    #     var currentUser = <%= raw json_escape(current_user.to_json) %>;
-    #   </script>
-    #
-    # It is necessary to +raw+ the result of +json_escape+, so that quotation marks
-    # don't get converted to <tt>&quot;</tt> entities. +json_escape+ doesn't
-    # automatically flag the result as HTML safe, since the raw value is unsafe to
-    # use inside HTML attributes.
-    #
-    # If your JSON is being used downstream for insertion into the DOM, be aware of
-    # whether or not it is being inserted via +html()+. Most jQuery plugins do this.
-    # If that is the case, be sure to +html_escape+ or +sanitize+ any user-generated
-    # content returned by your JSON.
-    #
-    # If you need to output JSON elsewhere in your HTML, you can just do something
-    # like this, as any unsafe characters (including quotation marks) will be
-    # automatically escaped for you:
-    #
-    #   <div data-user-info="<%= current_user.to_json %>">...</div>
-    #
-    # WARNING: this helper only works with valid JSON. Using this on non-JSON values
-    # will open up serious XSS vulnerabilities. For example, if you replace the
-    # +current_user.to_json+ in the example above with user input instead, the browser
-    # will happily eval() that string as JavaScript.
-    #
-    # The escaping performed in this method is identical to those performed in the
-    # Active Support JSON encoder when +ActiveSupport.escape_html_entities_in_json+ is
-    # set to true. Because this transformation is idempotent, this helper can be
-    # applied even if +ActiveSupport.escape_html_entities_in_json+ is already true.
-    #
-    # Therefore, when you are unsure if +ActiveSupport.escape_html_entities_in_json+
-    # is enabled, or if you are unsure where your JSON string originated from, it
-    # is recommended that you always apply this helper (other libraries, such as the
-    # JSON gem, do not provide this kind of protection by default; also some gems
-    # might override +to_json+ to bypass Active Support's encoder).
-    def json_escape(s)
-      result = s.to_s.gsub(JSON_ESCAPE_REGEXP, JSON_ESCAPE)
-      s.html_safe? ? result.html_safe : result
-    end
-
-    module_function :json_escape
-  end
-end
-
-class Object
-  def html_safe?
-    false
-  end
-end
-
-class Numeric
-  def html_safe?
-    true
-  end
-end
-
-module ActiveSupport #:nodoc:
-  class SafeBuffer < String
-    UNSAFE_STRING_METHODS = %w(
-      capitalize chomp chop delete downcase gsub lstrip next reverse rstrip
-      slice squeeze strip sub succ swapcase tr tr_s upcase
-    )
-
-    alias_method :original_concat, :concat
-    private :original_concat
-
-    # Raised when <tt>ActiveSupport::SafeBuffer#safe_concat</tt> is called on unsafe buffers.
-    class SafeConcatError < StandardError
-      def initialize
-        super 'Could not concatenate to the buffer because it is not html safe.'
-      end
-    end
-
-    def [](*args)
-      if args.size < 2
-        super
-      else
-        if html_safe?
-          new_safe_buffer = super
-
-          if new_safe_buffer
-            new_safe_buffer.instance_variable_set :@html_safe, true
-          end
-
-          new_safe_buffer
-        else
-          to_str[*args]
-        end
-      end
-    end
-
-    def safe_concat(value)
-      raise SafeConcatError unless html_safe?
-      original_concat(value)
-    end
-
-    def initialize(str = '')
-      @html_safe = true
-      super
-    end
-
-    def initialize_copy(other)
-      super
-      @html_safe = other.html_safe?
-    end
-
-    def clone_empty
-      self[0, 0]
-    end
-
-    def concat(value)
-      super(html_escape_interpolated_argument(value))
-    end
-    alias << concat
-
-    def prepend(value)
-      super(html_escape_interpolated_argument(value))
-    end
-
-    def +(other)
-      dup.concat(other)
-    end
-
-    def %(args)
-      case args
-      when Hash
-        escaped_args = Hash[args.map { |k,arg| [k, html_escape_interpolated_argument(arg)] }]
-      else
-        escaped_args = Array(args).map { |arg| html_escape_interpolated_argument(arg) }
-      end
-
-      self.class.new(super(escaped_args))
-    end
-
-    def html_safe?
-      defined?(@html_safe) && @html_safe
-    end
-
-    def to_s
-      self
-    end
-
-    def to_param
-      to_str
-    end
-
-    def encode_with(coder)
-      coder.represent_object nil, to_str
-    end
-
-    UNSAFE_STRING_METHODS.each do |unsafe_method|
-      if unsafe_method.respond_to?(unsafe_method)
-        class_eval <<-EOT, __FILE__, __LINE__ + 1
-          def #{unsafe_method}(*args, &block)       # def capitalize(*args, &block)
-            to_str.#{unsafe_method}(*args, &block)  #   to_str.capitalize(*args, &block)
-          end                                       # end
-
-          def #{unsafe_method}!(*args)              # def capitalize!(*args)
-            @html_safe = false                      #   @html_safe = false
-            super                                   #   super
-          end                                       # end
-        EOT
-      end
-    end
-
-    private
-
-    def html_escape_interpolated_argument(arg)
-      (!html_safe? || arg.html_safe?) ? arg : CGI.escapeHTML(arg.to_s)
-    end
-  end
-end
-
-class String
-  # Marks a string as trusted safe. It will be inserted into HTML with no
-  # additional escaping performed. It is your responsibility to ensure that the
-  # string contains no malicious content. This method is equivalent to the
-  # `raw` helper in views. It is recommended that you use `sanitize` instead of
-  # this method. It should never be called on user input.
-  def html_safe
-    ActiveSupport::SafeBuffer.new(self)
-  end
-end

data/vendor/bundle/gems/activesupport-5.0.2/lib/active_support/core_ext/string/starts_ends_with.rb

@@ -1,4 +0,0 @@
-class String
-  alias_method :starts_with?, :start_with?
-  alias_method :ends_with?, :end_with?
-end

data/vendor/bundle/gems/activesupport-5.0.2/lib/active_support/core_ext/string/strip.rb

@@ -1,23 +0,0 @@
-class String
-  # Strips indentation in heredocs.
-  #
-  # For example in
-  #
-  #   if options[:usage]
-  #     puts <<-USAGE.strip_heredoc
-  #       This command does such and such.
-  #
-  #       Supported options are:
-  #         -h         This message
-  #         ...
-  #     USAGE
-  #   end
-  #
-  # the user would see the usage message aligned against the left margin.
-  #
-  # Technically, it looks for the least indented non-empty line
-  # in the whole string, and removes that amount of leading whitespace.
-  def strip_heredoc
-    gsub(/^#{scan(/^[ \t]*(?=\S)/).min}/, ''.freeze)
-  end
-end

data/vendor/bundle/gems/activesupport-5.0.2/lib/active_support/core_ext/string/zones.rb

@@ -1,14 +0,0 @@
-require 'active_support/core_ext/string/conversions'
-require 'active_support/core_ext/time/zones'
-
-class String
-  # Converts String to a TimeWithZone in the current zone if Time.zone or Time.zone_default
-  # is set, otherwise converts String to a Time via String#to_time
-  def in_time_zone(zone = ::Time.zone)
-    if zone
-      ::Time.find_zone!(zone).parse(self)
-    else
-      to_time
-    end
-  end
-end

data/vendor/bundle/gems/activesupport-5.0.2/lib/active_support/core_ext/struct.rb

@@ -1,3 +0,0 @@
-require 'active_support/deprecation'
-
-ActiveSupport::Deprecation.warn("This file is deprecated and will be removed in Rails 5.1 with no replacement.")

data/vendor/bundle/gems/activesupport-5.0.2/lib/active_support/core_ext/time.rb

@@ -1,5 +0,0 @@
-require 'active_support/core_ext/time/acts_like'
-require 'active_support/core_ext/time/calculations'
-require 'active_support/core_ext/time/compatibility'
-require 'active_support/core_ext/time/conversions'
-require 'active_support/core_ext/time/zones'

data/vendor/bundle/gems/activesupport-5.0.2/lib/active_support/core_ext/time/acts_like.rb

@@ -1,8 +0,0 @@
-require 'active_support/core_ext/object/acts_like'
-
-class Time
-  # Duck-types as a Time-like class. See Object#acts_like?.
-  def acts_like_time?
-    true
-  end
-end

data/vendor/bundle/gems/activesupport-5.0.2/lib/active_support/core_ext/time/calculations.rb

@@ -1,290 +0,0 @@
-require 'active_support/duration'
-require 'active_support/core_ext/time/conversions'
-require 'active_support/time_with_zone'
-require 'active_support/core_ext/time/zones'
-require 'active_support/core_ext/date_and_time/calculations'
-require 'active_support/core_ext/date/calculations'
-
-class Time
-  include DateAndTime::Calculations
-
-  COMMON_YEAR_DAYS_IN_MONTH = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-
-  class << self
-    # Overriding case equality method so that it returns true for ActiveSupport::TimeWithZone instances
-    def ===(other)
-      super || (self == Time && other.is_a?(ActiveSupport::TimeWithZone))
-    end
-
-    # Returns the number of days in the given month.
-    # If no year is specified, it will use the current year.
-    def days_in_month(month, year = current.year)
-      if month == 2 && ::Date.gregorian_leap?(year)
-        29
-      else
-        COMMON_YEAR_DAYS_IN_MONTH[month]
-      end
-    end
-
-    # Returns the number of days in the given year.
-    # If no year is specified, it will use the current year.
-    def days_in_year(year = current.year)
-      days_in_month(2, year) + 337
-    end
-
-    # Returns <tt>Time.zone.now</tt> when <tt>Time.zone</tt> or <tt>config.time_zone</tt> are set, otherwise just returns <tt>Time.now</tt>.
-    def current
-      ::Time.zone ? ::Time.zone.now : ::Time.now
-    end
-
-    # Layers additional behavior on Time.at so that ActiveSupport::TimeWithZone and DateTime
-    # instances can be used when called with a single argument
-    def at_with_coercion(*args)
-      return at_without_coercion(*args) if args.size != 1
-
-      # Time.at can be called with a time or numerical value
-      time_or_number = args.first
-
-      if time_or_number.is_a?(ActiveSupport::TimeWithZone) || time_or_number.is_a?(DateTime)
-        at_without_coercion(time_or_number.to_f).getlocal
-      else
-        at_without_coercion(time_or_number)
-      end
-    end
-    alias_method :at_without_coercion, :at
-    alias_method :at, :at_with_coercion
-  end
-
-  # Returns the number of seconds since 00:00:00.
-  #
-  #   Time.new(2012, 8, 29,  0,  0,  0).seconds_since_midnight # => 0.0
-  #   Time.new(2012, 8, 29, 12, 34, 56).seconds_since_midnight # => 45296.0
-  #   Time.new(2012, 8, 29, 23, 59, 59).seconds_since_midnight # => 86399.0
-  def seconds_since_midnight
-    to_i - change(:hour => 0).to_i + (usec / 1.0e+6)
-  end
-
-  # Returns the number of seconds until 23:59:59.
-  #
-  #   Time.new(2012, 8, 29,  0,  0,  0).seconds_until_end_of_day # => 86399
-  #   Time.new(2012, 8, 29, 12, 34, 56).seconds_until_end_of_day # => 41103
-  #   Time.new(2012, 8, 29, 23, 59, 59).seconds_until_end_of_day # => 0
-  def seconds_until_end_of_day
-    end_of_day.to_i - to_i
-  end
-
-  # Returns the fraction of a second as a +Rational+
-  #
-  #   Time.new(2012, 8, 29, 0, 0, 0.5).sec_fraction # => (1/2)
-  def sec_fraction
-    subsec
-  end
-
-  # Returns a new Time where one or more of the elements have been changed according
-  # to the +options+ parameter. The time options (<tt>:hour</tt>, <tt>:min</tt>,
-  # <tt>:sec</tt>, <tt>:usec</tt>, <tt>:nsec</tt>) reset cascadingly, so if only
-  # the hour is passed, then minute, sec, usec and nsec is set to 0. If the hour
-  # and minute is passed, then sec, usec and nsec is set to 0. The +options+
-  # parameter takes a hash with any of these keys: <tt>:year</tt>, <tt>:month</tt>,
-  # <tt>:day</tt>, <tt>:hour</tt>, <tt>:min</tt>, <tt>:sec</tt>, <tt>:usec</tt>
-  # <tt>:nsec</tt>. Pass either <tt>:usec</tt> or <tt>:nsec</tt>, not both.
-  #
-  #   Time.new(2012, 8, 29, 22, 35, 0).change(day: 1)              # => Time.new(2012, 8, 1, 22, 35, 0)
-  #   Time.new(2012, 8, 29, 22, 35, 0).change(year: 1981, day: 1)  # => Time.new(1981, 8, 1, 22, 35, 0)
-  #   Time.new(2012, 8, 29, 22, 35, 0).change(year: 1981, hour: 0) # => Time.new(1981, 8, 29, 0, 0, 0)
-  def change(options)
-    new_year  = options.fetch(:year, year)
-    new_month = options.fetch(:month, month)
-    new_day   = options.fetch(:day, day)
-    new_hour  = options.fetch(:hour, hour)
-    new_min   = options.fetch(:min, options[:hour] ? 0 : min)
-    new_sec   = options.fetch(:sec, (options[:hour] || options[:min]) ? 0 : sec)
-
-    if new_nsec = options[:nsec]
-      raise ArgumentError, "Can't change both :nsec and :usec at the same time: #{options.inspect}" if options[:usec]
-      new_usec = Rational(new_nsec, 1000)
-    else
-      new_usec  = options.fetch(:usec, (options[:hour] || options[:min] || options[:sec]) ? 0 : Rational(nsec, 1000))
-    end
-
-    if utc?
-      ::Time.utc(new_year, new_month, new_day, new_hour, new_min, new_sec, new_usec)
-    elsif zone
-      ::Time.local(new_year, new_month, new_day, new_hour, new_min, new_sec, new_usec)
-    else
-      raise ArgumentError, 'argument out of range' if new_usec >= 1000000
-      ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec + (new_usec.to_r / 1000000), utc_offset)
-    end
-  end
-
-  # Uses Date to provide precise Time calculations for years, months, and days
-  # according to the proleptic Gregorian calendar. The +options+ parameter
-  # takes a hash with any of these keys: <tt>:years</tt>, <tt>:months</tt>,
-  # <tt>:weeks</tt>, <tt>:days</tt>, <tt>:hours</tt>, <tt>:minutes</tt>,
-  # <tt>:seconds</tt>.
-  #
-  #   Time.new(2015, 8, 1, 14, 35, 0).advance(seconds: 1) # => 2015-08-01 14:35:01 -0700
-  #   Time.new(2015, 8, 1, 14, 35, 0).advance(minutes: 1) # => 2015-08-01 14:36:00 -0700
-  #   Time.new(2015, 8, 1, 14, 35, 0).advance(hours: 1)   # => 2015-08-01 15:35:00 -0700
-  #   Time.new(2015, 8, 1, 14, 35, 0).advance(days: 1)    # => 2015-08-02 14:35:00 -0700
-  #   Time.new(2015, 8, 1, 14, 35, 0).advance(weeks: 1)   # => 2015-08-08 14:35:00 -0700
-  def advance(options)
-    unless options[:weeks].nil?
-      options[:weeks], partial_weeks = options[:weeks].divmod(1)
-      options[:days] = options.fetch(:days, 0) + 7 * partial_weeks
-    end
-
-    unless options[:days].nil?
-      options[:days], partial_days = options[:days].divmod(1)
-      options[:hours] = options.fetch(:hours, 0) + 24 * partial_days
-    end
-
-    d = to_date.advance(options)
-    d = d.gregorian if d.julian?
-    time_advanced_by_date = change(:year => d.year, :month => d.month, :day => d.day)
-    seconds_to_advance = \
-      options.fetch(:seconds, 0) +
-      options.fetch(:minutes, 0) * 60 +
-      options.fetch(:hours, 0) * 3600
-
-    if seconds_to_advance.zero?
-      time_advanced_by_date
-    else
-      time_advanced_by_date.since(seconds_to_advance)
-    end
-  end
-
-  # Returns a new Time representing the time a number of seconds ago, this is basically a wrapper around the Numeric extension
-  def ago(seconds)
-    since(-seconds)
-  end
-
-  # Returns a new Time representing the time a number of seconds since the instance time
-  def since(seconds)
-    self + seconds
-  rescue
-    to_datetime.since(seconds)
-  end
-  alias :in :since
-
-  # Returns a new Time representing the start of the day (0:00)
-  def beginning_of_day
-    change(:hour => 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 middle of the day (12:00)
-  def middle_of_day
-    change(:hour => 12)
-  end
-  alias :midday :middle_of_day
-  alias :noon :middle_of_day
-  alias :at_midday :middle_of_day
-  alias :at_noon :middle_of_day
-  alias :at_middle_of_day :middle_of_day
-
-  # Returns a new Time representing the end of the day, 23:59:59.999999
-  def end_of_day
-    change(
-      :hour => 23,
-      :min => 59,
-      :sec => 59,
-      :usec => Rational(999999999, 1000)
-    )
-  end
-  alias :at_end_of_day :end_of_day
-
-  # Returns a new Time representing the start of the hour (x:00)
-  def beginning_of_hour
-    change(:min => 0)
-  end
-  alias :at_beginning_of_hour :beginning_of_hour
-
-  # Returns a new Time representing the end of the hour, x:59:59.999999
-  def end_of_hour
-    change(
-      :min => 59,
-      :sec => 59,
-      :usec => Rational(999999999, 1000)
-    )
-  end
-  alias :at_end_of_hour :end_of_hour
-
-  # Returns a new Time representing the start of the minute (x:xx:00)
-  def beginning_of_minute
-    change(:sec => 0)
-  end
-  alias :at_beginning_of_minute :beginning_of_minute
-
-  # Returns a new Time representing the end of the minute, x:xx:59.999999
-  def end_of_minute
-    change(
-      :sec => 59,
-      :usec => Rational(999999999, 1000)
-    )
-  end
-  alias :at_end_of_minute :end_of_minute
-
-  # Returns a Range representing the whole day of the current time.
-  def all_day
-    beginning_of_day..end_of_day
-  end
-
-  def plus_with_duration(other) #:nodoc:
-    if ActiveSupport::Duration === other
-      other.since(self)
-    else
-      plus_without_duration(other)
-    end
-  end
-  alias_method :plus_without_duration, :+
-  alias_method :+, :plus_with_duration
-
-  def minus_with_duration(other) #:nodoc:
-    if ActiveSupport::Duration === other
-      other.until(self)
-    else
-      minus_without_duration(other)
-    end
-  end
-  alias_method :minus_without_duration, :-
-  alias_method :-, :minus_with_duration
-
-  # Time#- can also be used to determine the number of seconds between two Time instances.
-  # We're layering on additional behavior so that ActiveSupport::TimeWithZone instances
-  # are coerced into values that Time#- will recognize
-  def minus_with_coercion(other)
-    other = other.comparable_time if other.respond_to?(:comparable_time)
-    other.is_a?(DateTime) ? to_f - other.to_f : minus_without_coercion(other)
-  end
-  alias_method :minus_without_coercion, :-
-  alias_method :-, :minus_with_coercion
-
-  # Layers additional behavior on Time#<=> so that DateTime and ActiveSupport::TimeWithZone instances
-  # can be chronologically compared with a Time
-  def compare_with_coercion(other)
-    # we're avoiding Time#to_datetime and Time#to_time because they're expensive
-    if other.class == Time
-      compare_without_coercion(other)
-    elsif other.is_a?(Time)
-      compare_without_coercion(other.to_time)
-    else
-      to_datetime <=> other
-    end
-  end
-  alias_method :compare_without_coercion, :<=>
-  alias_method :<=>, :compare_with_coercion
-
-  # Layers additional behavior on Time#eql? so that ActiveSupport::TimeWithZone instances
-  # can be eql? to an equivalent Time
-  def eql_with_coercion(other)
-    # if other is an ActiveSupport::TimeWithZone, coerce a Time instance from it so we can do eql? comparison
-    other = other.comparable_time if other.respond_to?(:comparable_time)
-    eql_without_coercion(other)
-  end
-  alias_method :eql_without_coercion, :eql?
-  alias_method :eql?, :eql_with_coercion
-
-end