activesupport 4.1.15 → 4.2.11.3

data/lib/active_support/core_ext/string/output_safety.rb

@@ -1,5 +1,6 @@
 require 'erb'
 require 'active_support/core_ext/kernel/singleton_class'
+require 'active_support/deprecation'
 
 class ERB
   module Util
@@ -18,12 +19,7 @@ class ERB
     #   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_REGEXP, HTML_ESCAPE).html_safe
-      end
+      unwrapped_html_escape(s).html_safe
     end
 
     # Aliasing twice issues a warning "discarding old...". Remove first to avoid it.
@@ -35,6 +31,18 @@ class ERB
     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
+        s.gsub(HTML_ESCAPE_REGEXP, HTML_ESCAPE)
+      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')
@@ -124,7 +132,7 @@ 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 prepend
+      slice squeeze strip sub succ swapcase tr tr_s upcase
     )
 
     alias_method :original_concat, :concat
@@ -144,7 +152,7 @@ module ActiveSupport #:nodoc:
           new_safe_buffer = super
 
           if new_safe_buffer
-            new_safe_buffer.instance_eval { @html_safe = true }
+            new_safe_buffer.instance_variable_set :@html_safe, true
           end
 
           new_safe_buffer
@@ -174,14 +182,19 @@ module ActiveSupport #:nodoc:
     end
 
     def concat(value)
-      if !html_safe? || value.html_safe?
-        super(value)
-      else
-        super(ERB::Util.h(value))
-      end
+      super(html_escape_interpolated_argument(value))
     end
     alias << concat
 
+    def prepend(value)
+      super(html_escape_interpolated_argument(value))
+    end
+
+    def prepend!(value)
+      ActiveSupport::Deprecation.deprecation_warning "ActiveSupport::SafeBuffer#prepend!", :prepend
+      prepend value
+    end
+
     def +(other)
       dup.concat(other)
     end
@@ -231,12 +244,18 @@ module ActiveSupport #:nodoc:
     private
 
     def html_escape_interpolated_argument(arg)
-      (!html_safe? || arg.html_safe?) ? arg : ERB::Util.h(arg)
+      (!html_safe? || arg.html_safe?) ? arg :
+        arg.to_s.gsub(ERB::Util::HTML_ESCAPE_REGEXP, ERB::Util::HTML_ESCAPE)
     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 responsibilty 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

data/lib/active_support/core_ext/thread.rb

@@ -62,6 +62,13 @@ class Thread
     _locals.has_key?(key.to_sym)
   end
 
+  # Freezes the thread so that thread local variables cannot be set via
+  # Thread#thread_variable_set, nor can fiber local variables be set.
+  #
+  #   me = Thread.current
+  #   me.freeze
+  #   me.thread_variable_set(:oliver, "a")  #=> RuntimeError: can't modify frozen thread locals
+  #   me[:oliver] = "a"                     #=> RuntimeError: can't modify frozen thread locals
   def freeze
     _locals.freeze
     super

data/lib/active_support/core_ext/time.rb

@@ -1,5 +1,6 @@
 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/marshal'
 require 'active_support/core_ext/time/zones'

data/lib/active_support/core_ext/time/calculations.rb

@@ -3,6 +3,7 @@ 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
@@ -62,13 +63,21 @@ class Time
     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>) 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.  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>: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>. Path 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)
@@ -80,13 +89,20 @@ class Time
     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)
-    new_usec  = options.fetch(:usec, (options[:hour] || options[:min] || options[:sec]) ? 0 : Rational(nsec, 1000))
+
+    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
@@ -96,6 +112,12 @@ class Time
   # 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)
@@ -235,7 +257,9 @@ class Time
   # can be chronologically compared with a Time
   def compare_with_coercion(other)
     # we're avoiding Time#to_datetime cause it's expensive
-    if other.is_a?(Time)
+    if other.class == Time
+      compare_without_coercion(other)
+    elsif other.is_a?(Time)
       compare_without_coercion(other.to_time)
     else
       to_datetime <=> other

data/lib/active_support/core_ext/time/compatibility.rb

@@ -0,0 +1,14 @@
+require "active_support/core_ext/date_and_time/compatibility"
+require "active_support/core_ext/module/remove_method"
+
+class Time
+  include DateAndTime::Compatibility
+
+  remove_possible_method :to_time
+
+  # Either return +self+ or the time in the local system timezone depending
+  # on the setting of +ActiveSupport.to_time_preserves_timezone+.
+  def to_time
+    preserve_timezone ? self : getlocal
+  end
+end

data/lib/active_support/core_ext/time/conversions.rb

@@ -20,7 +20,7 @@ class Time
     :iso8601      => lambda { |time| time.iso8601 }
   }
 
-  # Converts to a formatted string. See DATE_FORMATS for builtin formats.
+  # Converts to a formatted string. See DATE_FORMATS for built-in formats.
   #
   # This method is aliased to <tt>to_s</tt>.
   #

data/lib/active_support/dependencies.rb

@@ -30,6 +30,10 @@ module ActiveSupport #:nodoc:
     mattr_accessor :loaded
     self.loaded = Set.new
 
+    # Stack of files being loaded.
+    mattr_accessor :loading
+    self.loading = []
+
     # Should we load files or require them?
     mattr_accessor :mechanism
     self.mechanism = ENV['NO_RELOAD'] ? :require : :load
@@ -180,10 +184,11 @@ module ActiveSupport #:nodoc:
         Dependencies.load_missing_constant(from_mod, const_name)
       end
 
-      # Dependencies assumes the name of the module reflects the nesting (unless
-      # it can be proven that is not the case), and the path to the file that
-      # defines the constant. Anonymous modules cannot follow these conventions
-      # and we assume therefore the user wants to refer to a top-level constant.
+      # We assume that the name of the module reflects the nesting
+      # (unless it can be proven that is not the case) and the path to the file
+      # that defines the constant. Anonymous modules cannot follow these
+      # conventions and therefore we assume that the user wants to refer to a
+      # top-level constant.
       def guess_for_anonymous(const_name)
         if Object.const_defined?(const_name)
           raise NameError.new "#{const_name} cannot be autoloaded from an anonymous class or module", const_name
@@ -200,7 +205,10 @@ module ActiveSupport #:nodoc:
     # Object includes this module.
     module Loadable #:nodoc:
       def self.exclude_from(base)
-        base.class_eval { define_method(:load, Kernel.instance_method(:load)) }
+        base.class_eval do
+          define_method(:load, Kernel.instance_method(:load))
+          private :load
+        end
       end
 
       def require_or_load(file_name)
@@ -236,18 +244,6 @@ module ActiveSupport #:nodoc:
         raise
       end
 
-      def load(file, wrap = false)
-        result = false
-        load_dependency(file) { result = super }
-        result
-      end
-
-      def require(file)
-        result = false
-        load_dependency(file) { result = super }
-        result
-      end
-
       # Mark the given constant as unloadable. Unloadable constants are removed
       # each time dependencies are cleared.
       #
@@ -264,6 +260,20 @@ module ActiveSupport #:nodoc:
       def unloadable(const_desc)
         Dependencies.mark_for_unload const_desc
       end
+
+      private
+
+      def load(file, wrap = false)
+        result = false
+        load_dependency(file) { result = super }
+        result
+      end
+
+      def require(file)
+        result = false
+        load_dependency(file) { result = super }
+        result
+      end
     end
 
     # Exception file-blaming.
@@ -316,6 +326,7 @@ module ActiveSupport #:nodoc:
     def clear
       log_call
       loaded.clear
+      loading.clear
       remove_unloadable_constants!
     end
 
@@ -328,6 +339,7 @@ module ActiveSupport #:nodoc:
       # Record that we've seen this file *before* loading it to avoid an
       # infinite loop with mutual dependencies.
       loaded << expanded
+      loading << expanded
 
       begin
         if load?
@@ -350,6 +362,8 @@ module ActiveSupport #:nodoc:
       rescue Exception
         loaded.delete expanded
         raise
+      ensure
+        loading.pop
       end
 
       # Record history *after* loading so first load gets warnings.
@@ -474,7 +488,7 @@ module ActiveSupport #:nodoc:
         expanded = File.expand_path(file_path)
         expanded.sub!(/\.rb\z/, '')
 
-        if loaded.include?(expanded)
+        if loading.include?(expanded)
           raise "Circular dependency detected while autoloading constant #{qualified_name}"
         else
           require_or_load(expanded, qualified_name)

data/lib/active_support/dependencies/autoload.rb

@@ -67,7 +67,7 @@ module ActiveSupport
     end
 
     def eager_load!
-      @_autoloads.values.each { |file| require file }
+      @_autoloads.each_value { |file| require file }
     end
 
     def autoloads

data/lib/active_support/deprecation.rb

@@ -32,7 +32,7 @@ module ActiveSupport
     # and the second is a library name
     #
     #   ActiveSupport::Deprecation.new('2.0', 'MyLibrary')
-    def initialize(deprecation_horizon = '4.2', gem_name = 'Rails')
+    def initialize(deprecation_horizon = '5.0', gem_name = 'Rails')
       self.gem_name = gem_name
       self.deprecation_horizon = deprecation_horizon
       # By default, warnings are not silenced and debugging is off.

data/lib/active_support/deprecation/behaviors.rb

@@ -20,7 +20,7 @@ module ActiveSupport
 
       log: ->(message, callstack) {
         logger =
-            if defined?(Rails) && Rails.logger
+            if defined?(Rails.logger) && Rails.logger
               Rails.logger
             else
               require 'active_support/logger'

data/lib/active_support/duration.rb

@@ -1,4 +1,3 @@
-require 'active_support/proxy_object'
 require 'active_support/core_ext/array/conversions'
 require 'active_support/core_ext/object/acts_like'
 
@@ -7,7 +6,7 @@ module ActiveSupport
   # Time#advance, respectively. It mainly supports the methods on Numeric.
   #
   #   1.month.ago       # equivalent to Time.now.advance(months: -1)
-  class Duration < ProxyObject
+  class Duration
     attr_accessor :value, :parts
 
     def initialize(value, parts) #:nodoc:
@@ -39,6 +38,10 @@ module ActiveSupport
     end
     alias :kind_of? :is_a?
 
+    def instance_of?(klass) # :nodoc:
+      Duration == klass || value.instance_of?(klass)
+    end
+
     # Returns +true+ if +other+ is also a Duration instance with the
     # same +value+, or if <tt>other == value</tt>.
     def ==(other)
@@ -49,8 +52,42 @@ module ActiveSupport
       end
     end
 
+    def to_s
+      @value.to_s
+    end
+
+    # Returns the number of seconds that this Duration represents.
+    #
+    #   1.minute.to_i   # => 60
+    #   1.hour.to_i     # => 3600
+    #   1.day.to_i      # => 86400
+    #
+    # Note that this conversion makes some assumptions about the
+    # duration of some periods, e.g. months are always 30 days
+    # and years are 365.25 days:
+    #
+    #   # equivalent to 30.days.to_i
+    #   1.month.to_i    # => 2592000
+    #
+    #   # equivalent to 365.25.days.to_i
+    #   1.year.to_i     # => 31557600
+    #
+    # In such cases, Ruby's core
+    # Date[http://ruby-doc.org/stdlib/libdoc/date/rdoc/Date.html] and
+    # Time[http://ruby-doc.org/stdlib/libdoc/time/rdoc/Time.html] should be used for precision
+    # date and time arithmetic.
+    def to_i
+      @value.to_i
+    end
+
+    # Returns +true+ if +other+ is also a Duration instance, which has the
+    # same parts as this one.
     def eql?(other)
-      other.is_a?(Duration) && self == other
+      Duration === other && other.value.eql?(value)
+    end
+
+    def hash
+      @value.hash
     end
 
     def self.===(other) #:nodoc:
@@ -85,6 +122,12 @@ module ActiveSupport
       to_i
     end
 
+    def respond_to_missing?(method, include_private=false) #:nodoc
+      @value.respond_to?(method, include_private)
+    end
+
+    delegate :<=>, to: :value
+
     protected
 
       def sum(sign, time = ::Time.current) #:nodoc:
@@ -105,8 +148,7 @@ module ActiveSupport
 
       # We define it as a workaround to Ruby 2.0.0-p353 bug.
       # For more information, check rails/rails#13055.
-      # It should be dropped once a new Ruby patch-level
-      # release after 2.0.0-p353 happens.
+      # Remove it when we drop support for 2.0.0-p353.
       def ===(other) #:nodoc:
         value === other
       end