backbone-deep-rails 0.0.2 → 0.0.3

data/vendor/bundle/gems/activesupport-3.2.11/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. Example:
-  #
-  #   env = "production".inquiry
-  #   env.production?  # => true
-  #   env.development? # => false
-  def inquiry
-    ActiveSupport::StringInquirer.new(self)
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/core_ext/string/interpolation.rb

@@ -1,2 +0,0 @@
-require 'active_support/i18n'
-require 'i18n/core_ext/string/interpolate'

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

@@ -1,72 +0,0 @@
-# encoding: utf-8
-require 'active_support/multibyte'
-
-class String
-  if RUBY_VERSION >= "1.9"
-    # == Multibyte proxy
-    #
-    # +mb_chars+ is a multibyte safe proxy for string methods.
-    #
-    # In Ruby 1.8 and older 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.
-    #
-    #   name = 'Claus Müller'
-    #   name.reverse # => "rell??M sualC"
-    #   name.length  # => 13
-    #
-    #   name.mb_chars.reverse.to_s # => "rellüM sualC"
-    #   name.mb_chars.length       # => 12
-    #
-    # In Ruby 1.9 and newer +mb_chars+ returns +self+ because String is (mostly) encoding aware. This means that
-    # it becomes easy to run one version of your code on multiple Ruby versions.
-    #
-    # == 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
-      if ActiveSupport::Multibyte.proxy_class.consumes?(self)
-        ActiveSupport::Multibyte.proxy_class.new(self)
-      else
-        self
-      end
-    end
-
-    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
-  else
-    def mb_chars
-      if ActiveSupport::Multibyte.proxy_class.wants?(self)
-        ActiveSupport::Multibyte.proxy_class.new(self)
-      else
-        self
-      end
-    end
-
-    # Returns true if the string has UTF-8 semantics (a String used for purely byte resources is unlikely to have
-    # them), returns false otherwise.
-    def is_utf8?
-      ActiveSupport::Multibyte::Chars.consumes?(self)
-    end
-  end
-end

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

@@ -1,186 +0,0 @@
-require 'erb'
-require 'active_support/core_ext/kernel/singleton_class'
-
-class ERB
-  module Util
-    HTML_ESCAPE = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;', "'" => '&#x27;' }
-    JSON_ESCAPE = { '&' => '\u0026', '>' => '\u003E', '<' => '\u003C' }
-
-    if RUBY_VERSION >= '1.9'
-      # 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 %>
-      #
-      # ==== Example:
-      #   puts html_escape("is a > 0 & a < 10?")
-      #   # => is a &gt; 0 &amp; a &lt; 10?
-      def html_escape(s)
-        s = s.to_s
-        if s.html_safe?
-          s
-        else
-          s.gsub(/[&"'><]/, HTML_ESCAPE).html_safe
-        end
-      end
-    else
-      def html_escape(s) #:nodoc:
-        s = s.to_s
-        if s.html_safe?
-          s
-        else
-          s.gsub(/[&"'><]/n) { |special| HTML_ESCAPE[special] }.html_safe
-        end
-      end
-    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
-
-    # A utility method for escaping HTML entities in JSON strings
-    # using \uXXXX JavaScript escape sequences for string literals:
-    #
-    #   json_escape("is a > 0 & a < 10?")
-    #   # => is a \u003E 0 \u0026 a \u003C 10?
-    #
-    # Note that after this operation is performed the output is not
-    # valid JSON. In particular double quotes are removed:
-    #
-    #   json_escape('{"name":"john","created_at":"2010-04-28T01:39:31Z","id":1}')
-    #   # => {name:john,created_at:2010-04-28T01:39:31Z,id:1}
-    #
-    # This method is also aliased as +j+, and available as a helper
-    # in Rails templates:
-    #
-    #   <%=j @person.to_json %>
-    #
-    def json_escape(s)
-      result = s.to_s.gsub(/[&"><]/) { |special| JSON_ESCAPE[special] }
-      s.html_safe? ? result.html_safe : result
-    end
-
-    alias j json_escape
-    module_function :j
-    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 = ["capitalize", "chomp", "chop", "delete", "downcase", "gsub", "lstrip", "next", "reverse", "rstrip", "slice", "squeeze", "strip", "sub", "succ", "swapcase", "tr", "tr_s", "upcase", "prepend"].freeze
-
-    alias_method :original_concat, :concat
-    private :original_concat
-
-    class SafeConcatError < StandardError
-      def initialize
-        super "Could not concatenate to the buffer because it is not html safe."
-      end
-    end
-
-    def [](*args)
-      return super if args.size < 2
-
-      if html_safe?
-        new_safe_buffer = super
-        new_safe_buffer.instance_eval { @html_safe = true }
-        new_safe_buffer
-      else
-        to_str[*args]
-      end
-    end
-
-    def safe_concat(value)
-      raise SafeConcatError unless html_safe?
-      original_concat(value)
-    end
-
-    def initialize(*)
-      @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)
-      if !html_safe? || value.html_safe?
-        super(value)
-      else
-        super(ERB::Util.h(value))
-      end
-    end
-    alias << concat
-
-    def +(other)
-      dup.concat(other)
-    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_scalar nil, to_str
-    end
-
-    def to_yaml(*args)
-      return super() if defined?(YAML::ENGINE) && !YAML::ENGINE.syck?
-      to_str.to_yaml(*args)
-    end
-
-    UNSAFE_STRING_METHODS.each do |unsafe_method|
-      if 'String'.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
-  end
-end
-
-class String
-  def html_safe
-    ActiveSupport::SafeBuffer.new(self)
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/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-3.2.11/lib/active_support/core_ext/string/strip.rb

@@ -1,26 +0,0 @@
-require 'active_support/core_ext/object/try'
-
-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 line in the whole string, and removes
-  # that amount of leading whitespace.
-  def strip_heredoc
-    indent = scan(/^[ \t]*(?=\S)/).min.try(:size) || 0
-    gsub(/^[ \t]{#{indent}}/, '')
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/core_ext/string/xchar.rb

@@ -1,18 +0,0 @@
-begin
-  # See http://fast-xs.rubyforge.org/ by Eric Wong.
-  # Also included with hpricot.
-  require 'fast_xs'
-rescue LoadError
-  # fast_xs extension unavailable
-else
-  begin
-    require 'builder'
-  rescue LoadError
-    # builder demands the first shot at defining String#to_xs
-  end
-
-  class String
-    alias_method :original_xs, :to_xs if method_defined?(:to_xs)
-    alias_method :to_xs, :fast_xs
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/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-3.2.11/lib/active_support/core_ext/time/calculations.rb

@@ -1,360 +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'
-
-class Time
-  COMMON_YEAR_DAYS_IN_MONTH = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-  DAYS_INTO_WEEK = { :monday => 0, :tuesday => 1, :wednesday => 2, :thursday => 3, :friday => 4, :saturday => 5, :sunday => 6 }
-
-  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
-
-    # Return 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 = now.year)
-      return 29 if month == 2 && ::Date.gregorian_leap?(year)
-      COMMON_YEAR_DAYS_IN_MONTH[month]
-    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 = ::Time.send(utc_or_local, year, month, day, hour, min, sec, usec)
-      # This check is needed because Time.utc(y) returns a time object in the 2000s for 0 <= y <= 138.
-      time.year == year ? time : ::DateTime.civil_from_format(utc_or_local, year, month, day, hour, min, sec)
-    rescue
-      ::DateTime.civil_from_format(utc_or_local, year, month, day, hour, min, sec)
-    end
-
-    # Wraps class method +time_with_datetime_fallback+ with +utc_or_local+ set to <tt>:utc</tt>.
-    def utc_time(*args)
-      time_with_datetime_fallback(:utc, *args)
-    end
-
-    # Wraps class method +time_with_datetime_fallback+ with +utc_or_local+ set to <tt>:local</tt>.
-    def local_time(*args)
-      time_with_datetime_fallback(:local, *args)
-    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
-  end
-
-  # Tells whether the Time object's time lies in the past
-  def past?
-    self < ::Time.current
-  end
-
-  # Tells whether the Time object's time is today
-  def today?
-    to_date == ::Date.current
-  end
-
-  # Tells whether the Time object's time lies in the future
-  def future?
-    self > ::Time.current
-  end
-
-  # Seconds since midnight: Time.now.seconds_since_midnight
-  def seconds_since_midnight
-    to_i - change(:hour => 0).to_i + (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, min, 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(
-      utc? ? :utc_time : :local_time,
-      options[:year]  || year,
-      options[:month] || month,
-      options[:day]   || day,
-      options[:hour]  || hour,
-      options[:min]   || (options[:hour] ? 0 : min),
-      options[:sec]   || ((options[:hour] || options[:min]) ? 0 : sec),
-      options[:usec]  || ((options[:hour] || options[:min] || options[:sec]) ? 0 : 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: <tt>:years</tt>,
-  # <tt>:months</tt>, <tt>:weeks</tt>, <tt>:days</tt>, <tt>:hours</tt>,
-  # <tt>:minutes</tt>, <tt>:seconds</tt>.
-  def advance(options)
-    unless options[:weeks].nil?
-      options[:weeks], partial_weeks = options[:weeks].divmod(1)
-      options[:days] = (options[:days] || 0) + 7 * partial_weeks
-    end
-
-    unless options[:days].nil?
-      options[:days], partial_days = options[:days].divmod(1)
-      options[:hours] = (options[:hours] || 0) + 24 * partial_days
-    end
-
-    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
-  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 time a number of specified weeks ago.
-  def weeks_ago(weeks)
-    advance(:weeks => -weeks)
-  end
-
-  # 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 prev_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 prev_month
-    months_ago(1)
-  end
-
-  # Short-hand for months_since(1)
-  def next_month
-    months_since(1)
-  end
-
-  # Returns number of days to start of this week, week starts on start_day (default is :monday).
-  def days_to_week_start(start_day = :monday)
-    start_day_number = DAYS_INTO_WEEK[start_day]
-    current_day_number = wday != 0 ? wday - 1 : 6
-    days_span = current_day_number - start_day_number
-    days_span >= 0 ? days_span : 7 + days_span
-  end
-
-  # Returns a new Time representing the "start" of this week, week starts on start_day (default is :monday, i.e. Monday, 0:00).
-  def beginning_of_week(start_day = :monday)
-    days_to_start = days_to_week_start(start_day)
-    (self - days_to_start.days).midnight
-  end
-  alias :at_beginning_of_week :beginning_of_week
-
-  # Returns a new +Date+/+DateTime+ representing the start of this week. Week is
-  # assumed to start on a Monday. +DateTime+ objects have their time set to 0:00.
-  def monday
-    beginning_of_week
-  end
-
-  # Returns a new Time representing the end of this week, week starts on start_day (default is :monday, i.e. end of Sunday).
-  def end_of_week(start_day = :monday)
-    days_to_end =  6 - days_to_week_start(start_day)
-    (self + days_to_end.days).end_of_day
-  end
-  alias :at_end_of_week :end_of_week
-
-  # Returns a new +Date+/+DateTime+ representing the end of this week. Week is
-  # assumed to start on a Monday. +DateTime+ objects have their time set to 23:59:59.
-  def sunday
-    end_of_week
-  end
-
-  # Returns a new Time representing the start of the given day in the previous week (default is :monday).
-  def prev_week(day = :monday)
-    ago(1.week).beginning_of_week.since(DAYS_INTO_WEEK[day].day).change(:hour => 0)
-  end
-
-  # Returns a new Time representing the start of the given day in next week (default is :monday).
-  def next_week(day = :monday)
-    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 - seconds_since_midnight).change(:usec => 0)
-    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 end of the day, 23:59:59.999999 (.999999999 in ruby1.9)
-  def end_of_day
-    change(:hour => 23, :min => 59, :sec => 59, :usec => 999999.999)
-  end
-
-  # 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 (.999999999 in ruby1.9)
-  def end_of_hour
-    change(
-      :min => 59,
-      :sec => 59,
-      :usec => 999999.999
-    )
-  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)
-  end
-  alias :at_beginning_of_month :beginning_of_month
-
-  # Returns a new Time representing the end of the month (end of the last day of the month)
-  def end_of_month
-    #self - ((self.mday-1).days + self.seconds_since_midnight)
-    last_day = ::Time.days_in_month(month, year)
-    change(:day => last_day, :hour => 23, :min => 59, :sec => 59, :usec => 999999.999)
-  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 <= month })
-  end
-  alias :at_beginning_of_quarter :beginning_of_quarter
-
-  # Returns a new Time representing the end of the quarter (end of the last day of march, june, september, december)
-  def end_of_quarter
-    beginning_of_month.change(:month => [3, 6, 9, 12].detect { |m| m >= month }).end_of_month
-  end
-  alias :at_end_of_quarter :end_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)
-  end
-  alias :at_beginning_of_year :beginning_of_year
-
-  # Returns a new Time representing the end of the year (end of the 31st of december)
-  def end_of_year
-    change(:month => 12, :day => 31, :hour => 23, :min => 59, :sec => 59, :usec => 999999.999)
-  end
-  alias :at_end_of_year :end_of_year
-
-  # Convenience method which returns a new Time representing the time 1 day ago
-  def yesterday
-    advance(:days => -1)
-  end
-
-  # Convenience method which returns a new Time representing the time 1 day since the instance time
-  def tomorrow
-    advance(:days => 1)
-  end
-
-  # Returns a Range representing the whole day of the current time.
-  def all_day
-    beginning_of_day..end_of_day
-  end
-
-  # Returns a Range representing the whole week of the current time. Week starts on start_day (default is :monday, i.e. end of Sunday).
-  def all_week(start_day = :monday)
-    beginning_of_week(start_day)..end_of_week(start_day)
-  end
-
-  # Returns a Range representing the whole month of the current time.
-  def all_month
-    beginning_of_month..end_of_month
-  end
-
-  # Returns a Range representing the whole quarter of the current time.
-  def all_quarter
-    beginning_of_quarter..end_of_quarter
-  end
-
-  # Returns a Range representing the whole year of the current time.
-  def all_year
-    beginning_of_year..end_of_year
-  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 cause it's expensive
-    other.is_a?(Time) ? compare_without_coercion(other.to_time) : to_datetime <=> other
-  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