activesupport 4.2.11.3 → 5.2.8.1

data/lib/active_support/core_ext/object/blank.rb

@@ -1,4 +1,7 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
+require "active_support/core_ext/regexp"
+require "concurrent/map"
 
 class Object
   # An object is blank if it's false, empty, or a whitespace string.
@@ -100,6 +103,9 @@ end
 
 class String
   BLANK_RE = /\A[[:space:]]*\z/
+  ENCODED_BLANKS = Concurrent::Map.new do |h, enc|
+    h[enc] = Regexp.new(BLANK_RE.source.encode(enc), BLANK_RE.options | Regexp::FIXEDENCODING)
+  end
 
   # A string is blank if it's empty or contains whitespaces only:
   #
@@ -114,7 +120,15 @@ class String
   #
   # @return [true, false]
   def blank?
-    BLANK_RE === self
+    # The regexp that matches blank strings is expensive. For the case of empty
+    # strings we can speed up this method (~3.5x) with an empty? call. The
+    # penalty for the rest of strings is marginal.
+    empty? ||
+      begin
+        BLANK_RE.match?(self)
+      rescue Encoding::CompatibilityError
+        ENCODED_BLANKS[self.encoding].match?(self)
+      end
   end
 end
 
@@ -129,3 +143,14 @@ class Numeric #:nodoc:
     false
   end
 end
+
+class Time #:nodoc:
+  # No Time is blank:
+  #
+  #   Time.now.blank? # => false
+  #
+  # @return [false]
+  def blank?
+    false
+  end
+end

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

@@ -1,4 +1,6 @@
-require 'active_support/core_ext/object/to_param'
-require 'active_support/core_ext/object/to_query'
-require 'active_support/core_ext/array/conversions'
-require 'active_support/core_ext/hash/conversions'
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/to_param"
+require "active_support/core_ext/object/to_query"
+require "active_support/core_ext/array/conversions"
+require "active_support/core_ext/hash/conversions"

data/lib/active_support/core_ext/object/deep_dup.rb

@@ -1,4 +1,6 @@
-require 'active_support/core_ext/object/duplicable'
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/duplicable"
 
 class Object
   # Returns a deep copy of object if it's duplicable. If it's
@@ -25,7 +27,7 @@ class Array
   #   array[1][2] # => nil
   #   dup[1][2]   # => 4
   def deep_dup
-    map { |it| it.deep_dup }
+    map(&:deep_dup)
   end
 end
 
@@ -39,8 +41,15 @@ class Hash
   #   hash[:a][:c] # => nil
   #   dup[:a][:c]  # => "c"
   def deep_dup
-    each_with_object(dup) do |(key, value), hash|
-      hash[key.deep_dup] = value.deep_dup
+    hash = dup
+    each_pair do |key, value|
+      if key.frozen? && ::String === key
+        hash[key] = value.deep_dup
+      else
+        hash.delete(key)
+        hash[key.deep_dup] = value.deep_dup
+      end
     end
+    hash
   end
 end

data/lib/active_support/core_ext/object/duplicable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #--
 # Most objects are cloneable, but not all. For example you can't dup methods:
 #
@@ -19,7 +21,7 @@
 class Object
   # Can you safely dup this object?
   #
-  # False for +nil+, +false+, +true+, symbol, number and BigDecimal(in 1.9.x) objects;
+  # False for method objects;
   # true otherwise.
   def duplicable?
     true
@@ -74,7 +76,7 @@ end
 class Symbol
   begin
     :symbol.dup # Ruby 2.4.x.
-    'symbol_from_string'.to_sym.dup # Some symbols can't `dup` in Ruby 2.4.0.
+    "symbol_from_string".to_sym.dup # Some symbols can't `dup` in Ruby 2.4.0.
   rescue TypeError
 
     # Symbols are not duplicable:
@@ -102,19 +104,14 @@ class Numeric
   end
 end
 
-require 'bigdecimal'
+require "bigdecimal"
 class BigDecimal
-  # Needed to support Ruby 1.9.x, as it doesn't allow dup on BigDecimal, instead
-  # raises TypeError exception. Checking here on the runtime whether BigDecimal
-  # will allow dup or not.
-  begin
-    BigDecimal.new('4.56').dup
-
-    def duplicable?
-      true
-    end
-  rescue TypeError
-    # can't dup, so use superclass implementation
+  # BigDecimals are duplicable:
+  #
+  #   BigDecimal("1.2").duplicable? # => true
+  #   BigDecimal("1.2").dup         # => #<BigDecimal:...,'0.12E1',18(18)>
+  def duplicable?
+    true
   end
 end
 
@@ -127,3 +124,33 @@ class Method
     false
   end
 end
+
+class Complex
+  begin
+    Complex(1).dup
+  rescue TypeError
+
+    # Complexes are not duplicable:
+    #
+    #   Complex(1).duplicable? # => false
+    #   Complex(1).dup         # => TypeError: can't copy Complex
+    def duplicable?
+      false
+    end
+  end
+end
+
+class Rational
+  begin
+    Rational(1).dup
+  rescue TypeError
+
+    # Rationals are not duplicable:
+    #
+    #   Rational(1).duplicable? # => false
+    #   Rational(1).dup         # => TypeError: can't copy Rational
+    def duplicable?
+      false
+    end
+  end
+end

data/lib/active_support/core_ext/object/inclusion.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Object
   # Returns true if this object is included in the argument. Argument must be
   # any object which responds to +#include?+. Usage:
@@ -5,7 +7,7 @@ class Object
   #   characters = ["Konata", "Kagami", "Tsukasa"]
   #   "Konata".in?(characters) # => true
   #
-  # This will throw an ArgumentError if the argument doesn't respond
+  # This will throw an +ArgumentError+ if the argument doesn't respond
   # to +#include?+.
   def in?(another_object)
     another_object.include?(self)
@@ -18,10 +20,10 @@ class Object
   #
   #   params[:bucket_type].presence_in %w( project calendar )
   #
-  # This will throw an ArgumentError if the argument doesn't respond to +#include?+.
+  # This will throw an +ArgumentError+ if the argument doesn't respond to +#include?+.
   #
   # @return [Object]
   def presence_in(another_object)
-    self.in?(another_object) ? self : nil
+    in?(another_object) ? self : nil
   end
 end

data/lib/active_support/core_ext/object/instance_variables.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Object
   # Returns a hash with string keys that maps instance variable names without "@" to their
   # corresponding values.
@@ -23,6 +25,6 @@ class Object
   #
   #   C.new(0, 1).instance_variable_names # => ["@y", "@x"]
   def instance_variable_names
-    instance_variables.map { |var| var.to_s }
+    instance_variables.map(&:to_s)
   end
 end

data/lib/active_support/core_ext/object/json.rb

@@ -1,15 +1,18 @@
+# frozen_string_literal: true
+
 # Hack to load json gem first so we can overwrite its to_json.
-require 'json'
-require 'bigdecimal'
-require 'active_support/core_ext/big_decimal/conversions' # for #to_s
-require 'active_support/core_ext/hash/except'
-require 'active_support/core_ext/hash/slice'
-require 'active_support/core_ext/object/instance_variables'
-require 'time'
-require 'active_support/core_ext/time/conversions'
-require 'active_support/core_ext/date_time/conversions'
-require 'active_support/core_ext/date/conversions'
-require 'active_support/core_ext/module/aliasing'
+require "json"
+require "bigdecimal"
+require "uri/generic"
+require "pathname"
+require "active_support/core_ext/big_decimal/conversions" # for #to_s
+require "active_support/core_ext/hash/except"
+require "active_support/core_ext/hash/slice"
+require "active_support/core_ext/object/instance_variables"
+require "time"
+require "active_support/core_ext/time/conversions"
+require "active_support/core_ext/date_time/conversions"
+require "active_support/core_ext/date/conversions"
 
 # The JSON gem adds a few modules to Ruby core classes containing :to_json definition, overwriting
 # their default behavior. That said, we need to define the basic to_json method in all of them,
@@ -26,22 +29,25 @@ require 'active_support/core_ext/module/aliasing'
 # bypassed completely. This means that as_json won't be invoked and the JSON gem will simply
 # ignore any options it does not natively understand. This also means that ::JSON.{generate,dump}
 # should give exactly the same results with or without active support.
-[Enumerable, Object, Array, FalseClass, Float, Hash, Integer, NilClass, String, TrueClass].each do |klass|
-  klass.class_eval do
-    def to_json_with_active_support_encoder(options = nil) # :nodoc:
+
+module ActiveSupport
+  module ToJsonWithActiveSupportEncoder # :nodoc:
+    def to_json(options = nil)
       if options.is_a?(::JSON::State)
         # Called from JSON.{generate,dump}, forward it to JSON gem's to_json
-        self.to_json_without_active_support_encoder(options)
+        super(options)
       else
         # to_json is being invoked directly, use ActiveSupport's encoder
         ActiveSupport::JSON.encode(self, options)
       end
     end
-
-    alias_method_chain :to_json, :active_support_encoder
   end
 end
 
+[Object, Array, FalseClass, Float, Hash, Integer, NilClass, String, TrueClass, Enumerable].reverse_each do |klass|
+  klass.prepend(ActiveSupport::ToJsonWithActiveSupportEncoder)
+end
+
 class Object
   def as_json(options = nil) #:nodoc:
     if respond_to?(:to_hash)
@@ -129,6 +135,12 @@ module Enumerable
   end
 end
 
+class IO
+  def as_json(options = nil) #:nodoc:
+    to_s
+  end
+end
+
 class Range
   def as_json(options = nil) #:nodoc:
     to_s
@@ -185,13 +197,31 @@ class DateTime
     if ActiveSupport::JSON::Encoding.use_standard_json_time_format
       xmlschema(ActiveSupport::JSON::Encoding.time_precision)
     else
-      strftime('%Y/%m/%d %H:%M:%S %z')
+      strftime("%Y/%m/%d %H:%M:%S %z")
     end
   end
 end
 
+class URI::Generic #:nodoc:
+  def as_json(options = nil)
+    to_s
+  end
+end
+
+class Pathname #:nodoc:
+  def as_json(options = nil)
+    to_s
+  end
+end
+
 class Process::Status #:nodoc:
   def as_json(options = nil)
-    { :exitstatus => exitstatus, :pid => pid }
+    { exitstatus: exitstatus, pid: pid }
+  end
+end
+
+class Exception
+  def as_json(options = nil)
+    to_s
   end
 end

data/lib/active_support/core_ext/object/to_param.rb

@@ -1 +1,3 @@
-require 'active_support/core_ext/object/to_query'
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/to_query"

data/lib/active_support/core_ext/object/to_query.rb

@@ -1,4 +1,6 @@
-require 'cgi'
+# frozen_string_literal: true
+
+require "cgi"
 
 class Object
   # Alias of <tt>to_s</tt>.
@@ -38,7 +40,7 @@ class Array
   # Calls <tt>to_param</tt> on all its elements and joins the result with
   # slashes. This is used by <tt>url_for</tt> in Action Pack.
   def to_param
-    collect { |e| e.to_param }.join '/'
+    collect(&:to_param).join "/"
   end
 
   # Converts an array into a string suitable for use as a URL query string,
@@ -51,7 +53,7 @@ class Array
     if empty?
       nil.to_query(prefix)
     else
-      collect { |value| value.to_query(prefix) }.join '&'
+      collect { |value| value.to_query(prefix) }.join "&"
     end
   end
 end
@@ -73,11 +75,14 @@ class Hash
   #
   # This method is also aliased as +to_param+.
   def to_query(namespace = nil)
-    collect do |key, value|
+    query = collect do |key, value|
       unless (value.is_a?(Hash) || value.is_a?(Array)) && value.empty?
         value.to_query(namespace ? "#{namespace}[#{key}]" : key)
       end
-    end.compact.sort! * '&'
+    end.compact
+
+    query.sort! unless namespace.to_s.include?("[]")
+    query.join("&")
   end
 
   alias_method :to_param, :to_query

data/lib/active_support/core_ext/object/try.rb

@@ -1,4 +1,36 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module ActiveSupport
+  module Tryable #:nodoc:
+    def try(*a, &b)
+      try!(*a, &b) if a.empty? || respond_to?(a.first)
+    end
+
+    def try!(*a, &b)
+      if a.empty? && block_given?
+        if b.arity == 0
+          instance_eval(&b)
+        else
+          yield self
+        end
+      else
+        public_send(*a, &b)
+      end
+    end
+  end
+end
+
 class Object
+  include ActiveSupport::Tryable
+
+  ##
+  # :method: try
+  #
+  # :call-seq:
+  #   try(*a, &b)
+  #
   # Invokes the public method whose name goes as first argument just like
   # +public_send+ does, except that if the receiver does not respond to it the
   # call returns +nil+ rather than raising an exception.
@@ -21,11 +53,11 @@ class Object
   #
   # +try+ will also return +nil+ if the receiver does not respond to the method:
   #
-  #   @person.try(:non_existing_method) #=> nil
+  #   @person.try(:non_existing_method) # => nil
   #
   # instead of
   #
-  #   @person.non_existing_method if @person.respond_to?(:non_existing_method) #=> nil
+  #   @person.non_existing_method if @person.respond_to?(:non_existing_method) # => nil
   #
   # +try+ returns +nil+ when called on +nil+ regardless of whether it responds
   # to the method:
@@ -56,27 +88,40 @@ class Object
   #
   # Please also note that +try+ is defined on +Object+. Therefore, it won't work
   # with instances of classes that do not have +Object+ among their ancestors,
-  # like direct subclasses of +BasicObject+. For example, using +try+ with
-  # +SimpleDelegator+ will delegate +try+ to the target instead of calling it on
-  # the delegator itself.
-  def try(*a, &b)
-    try!(*a, &b) if a.empty? || respond_to?(a.first)
-  end
+  # like direct subclasses of +BasicObject+.
 
-  # Same as #try, but will raise a NoMethodError exception if the receiver is not +nil+ and
-  # does not implement the tried method.
+  ##
+  # :method: try!
+  #
+  # :call-seq:
+  #   try!(*a, &b)
+  #
+  # Same as #try, but raises a +NoMethodError+ exception if the receiver is
+  # not +nil+ and does not implement the tried method.
+  #
+  #   "a".try!(:upcase) # => "A"
+  #   nil.try!(:upcase) # => nil
+  #   123.try!(:upcase) # => NoMethodError: undefined method `upcase' for 123:Integer
+end
 
-  def try!(*a, &b)
-    if a.empty? && block_given?
-      if b.arity == 0
-        instance_eval(&b)
-      else
-        yield self
-      end
-    else
-      public_send(*a, &b)
-    end
-  end
+class Delegator
+  include ActiveSupport::Tryable
+
+  ##
+  # :method: try
+  #
+  # :call-seq:
+  #   try(a*, &b)
+  #
+  # See Object#try
+
+  ##
+  # :method: try!
+  #
+  # :call-seq:
+  #   try!(a*, &b)
+  #
+  # See Object#try!
 end
 
 class NilClass
@@ -94,6 +139,9 @@ class NilClass
     nil
   end
 
+  # Calling +try!+ on +nil+ always returns +nil+.
+  #
+  #   nil.try!(:name) # => nil
   def try!(*args)
     nil
   end

data/lib/active_support/core_ext/object/with_options.rb

@@ -1,4 +1,6 @@
-require 'active_support/option_merger'
+# frozen_string_literal: true
+
+require "active_support/option_merger"
 
 class Object
   # An elegant way to factor duplication out of options passed to a series of
@@ -7,7 +9,7 @@ class Object
   # provided. Each method called on the block variable must take an options
   # hash as its final argument.
   #
-  # Without <tt>with_options></tt>, this code contains duplication:
+  # Without <tt>with_options</tt>, this code contains duplication:
   #
   #   class Account < ActiveRecord::Base
   #     has_many :customers, dependent: :destroy
@@ -60,7 +62,18 @@ class Object
   #
   #   validates :content, length: { minimum: 50 }, if: -> { content.present? }
   #
-  # Hence the inherited default for `if` key is ignored.
+  # Hence the inherited default for +if+ key is ignored.
+  #
+  # NOTE: You cannot call class methods implicitly inside of with_options.
+  # You can access these methods using the class name instead:
+  #
+  #   class Phone < ActiveRecord::Base
+  #     enum phone_number_type: [home: 0, office: 1, mobile: 2]
+  #
+  #     with_options presence: true do
+  #       validates :phone_number_type, inclusion: { in: Phone.phone_number_types.keys }
+  #     end
+  #   end
   #
   def with_options(options, &block)
     option_merger = ActiveSupport::OptionMerger.new(self, options)

data/lib/active_support/core_ext/object.rb

@@ -1,15 +1,16 @@
-require 'active_support/core_ext/object/acts_like'
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/object/duplicable'
-require 'active_support/core_ext/object/deep_dup'
-require 'active_support/core_ext/object/itself'
-require 'active_support/core_ext/object/try'
-require 'active_support/core_ext/object/inclusion'
+# frozen_string_literal: true
 
-require 'active_support/core_ext/object/conversions'
-require 'active_support/core_ext/object/instance_variables'
+require "active_support/core_ext/object/acts_like"
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/object/duplicable"
+require "active_support/core_ext/object/deep_dup"
+require "active_support/core_ext/object/try"
+require "active_support/core_ext/object/inclusion"
 
-require 'active_support/core_ext/object/json'
-require 'active_support/core_ext/object/to_param'
-require 'active_support/core_ext/object/to_query'
-require 'active_support/core_ext/object/with_options'
+require "active_support/core_ext/object/conversions"
+require "active_support/core_ext/object/instance_variables"
+
+require "active_support/core_ext/object/json"
+require "active_support/core_ext/object/to_param"
+require "active_support/core_ext/object/to_query"
+require "active_support/core_ext/object/with_options"

data/lib/active_support/core_ext/range/compare_range.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module CompareWithRange #:nodoc:
+    # Extends the default Range#=== to support range comparisons.
+    #  (1..5) === (1..5) # => true
+    #  (1..5) === (2..3) # => true
+    #  (1..5) === (2..6) # => false
+    #
+    # The native Range#=== behavior is untouched.
+    #  ('a'..'f') === ('c') # => true
+    #  (5..9) === (11) # => false
+    def ===(value)
+      if value.is_a?(::Range)
+        # 1...10 includes 1..9 but it does not include 1..10.
+        operator = exclude_end? && !value.exclude_end? ? :< : :<=
+        super(value.first) && value.last.send(operator, last)
+      else
+        super
+      end
+    end
+
+    # Extends the default Range#include? to support range comparisons.
+    #  (1..5).include?(1..5) # => true
+    #  (1..5).include?(2..3) # => true
+    #  (1..5).include?(2..6) # => false
+    #
+    # The native Range#include? behavior is untouched.
+    #  ('a'..'f').include?('c') # => true
+    #  (5..9).include?(11) # => false
+    def include?(value)
+      if value.is_a?(::Range)
+        # 1...10 includes 1..9 but it does not include 1..10.
+        operator = exclude_end? && !value.exclude_end? ? :< : :<=
+        super(value.first) && value.last.send(operator, last)
+      else
+        super
+      end
+    end
+
+    # Extends the default Range#cover? to support range comparisons.
+    #  (1..5).cover?(1..5) # => true
+    #  (1..5).cover?(2..3) # => true
+    #  (1..5).cover?(2..6) # => false
+    #
+    # The native Range#cover? behavior is untouched.
+    #  ('a'..'f').cover?('c') # => true
+    #  (5..9).cover?(11) # => false
+    def cover?(value)
+      if value.is_a?(::Range)
+        # 1...10 covers 1..9 but it does not cover 1..10.
+        operator = exclude_end? && !value.exclude_end? ? :< : :<=
+        super(value.first) && value.last.send(operator, last)
+      else
+        super
+      end
+    end
+  end
+end
+
+Range.prepend(ActiveSupport::CompareWithRange)

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

@@ -1,19 +1,39 @@
-class Range
+# frozen_string_literal: true
+
+module ActiveSupport::RangeWithFormat
   RANGE_FORMATS = {
-    :db => Proc.new { |start, stop| "BETWEEN '#{start.to_s(:db)}' AND '#{stop.to_s(:db)}'" }
+    db: -> (start, stop) do
+      case start
+      when String then "BETWEEN '#{start}' AND '#{stop}'"
+      else
+        "BETWEEN '#{start.to_s(:db)}' AND '#{stop.to_s(:db)}'"
+      end
+    end
   }
 
-  # Gives a human readable format of the range.
+  # Convert range to a formatted string. See RANGE_FORMATS for predefined formats.
+  #
+  #   range = (1..100)           # => 1..100
   #
-  #   (1..100).to_formatted_s # => "1..100"
-  def to_formatted_s(format = :default)
+  #   range.to_s                 # => "1..100"
+  #   range.to_s(:db)            # => "BETWEEN '1' AND '100'"
+  #
+  # == Adding your own range formats to to_s
+  # You can add your own formats to the Range::RANGE_FORMATS hash.
+  # Use the format name as the hash key and a Proc instance.
+  #
+  #   # config/initializers/range_formats.rb
+  #   Range::RANGE_FORMATS[:short] = ->(start, stop) { "Between #{start.to_s(:db)} and #{stop.to_s(:db)}" }
+  def to_s(format = :default)
     if formatter = RANGE_FORMATS[format]
       formatter.call(first, last)
     else
-      to_default_s
+      super()
     end
   end
 
   alias_method :to_default_s, :to_s
-  alias_method :to_s, :to_formatted_s
+  alias_method :to_formatted_s, :to_s
 end
+
+Range.prepend(ActiveSupport::RangeWithFormat)