activesupport 4.0.12 → 7.0.2.4

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

@@ -1,39 +1,47 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
+require "concurrent/map"
 
 class Object
   # An object is blank if it's false, empty, or a whitespace string.
-  # For example, '', '   ', +nil+, [], and {} are all blank.
+  # For example, +nil+, '', '   ', [], {}, and +false+ are all blank.
+  #
+  # This simplifies
   #
-  # This simplifies:
+  #   !address || address.empty?
   #
-  #   if address.nil? || address.empty?
+  # to
   #
-  # ...to:
+  #   address.blank?
   #
-  #   if address.blank?
+  # @return [true, false]
   def blank?
-    respond_to?(:empty?) ? empty? : !self
+    respond_to?(:empty?) ? !!empty? : !self
   end
 
-  # An object is present if it's not <tt>blank?</tt>.
+  # An object is present if it's not blank.
+  #
+  # @return [true, false]
   def present?
     !blank?
   end
 
-  # Returns object if it's <tt>present?</tt> otherwise returns +nil+.
-  # <tt>object.presence</tt> is equivalent to <tt>object.present? ? object : nil</tt>.
+  # Returns the receiver if it's present otherwise returns +nil+.
+  # <tt>object.presence</tt> is equivalent to
   #
-  # This is handy for any representation of objects where blank is the same
-  # as not present at all. For example, this simplifies a common check for
-  # HTTP POST/query parameters:
+  #    object.present? ? object : nil
+  #
+  # For example, something like
   #
   #   state   = params[:state]   if params[:state].present?
   #   country = params[:country] if params[:country].present?
   #   region  = state || country || 'US'
   #
-  # ...becomes:
+  # becomes
   #
   #   region = params[:state].presence || params[:country].presence || 'US'
+  #
+  # @return [Object]
   def presence
     self if present?
   end
@@ -43,6 +51,8 @@ class NilClass
   # +nil+ is blank:
   #
   #   nil.blank? # => true
+  #
+  # @return [true]
   def blank?
     true
   end
@@ -52,6 +62,8 @@ class FalseClass
   # +false+ is blank:
   #
   #   false.blank? # => true
+  #
+  # @return [true]
   def blank?
     true
   end
@@ -61,6 +73,8 @@ class TrueClass
   # +true+ is not blank:
   #
   #   true.blank? # => false
+  #
+  # @return [false]
   def blank?
     false
   end
@@ -71,6 +85,8 @@ class Array
   #
   #   [].blank?      # => true
   #   [1,2,3].blank? # => false
+  #
+  # @return [true, false]
   alias_method :blank?, :empty?
 end
 
@@ -79,26 +95,60 @@ class Hash
   #
   #   {}.blank?                # => true
   #   { key: 'value' }.blank?  # => false
+  #
+  # @return [true, false]
   alias_method :blank?, :empty?
 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:
   #
-  #   ''.blank?                 # => true
-  #   '   '.blank?              # => true
-  #   '　'.blank?               # => true
-  #   ' something here '.blank? # => false
+  #   ''.blank?       # => true
+  #   '   '.blank?    # => true
+  #   "\t\n\r".blank? # => true
+  #   ' blah '.blank? # => false
+  #
+  # Unicode whitespace is supported:
+  #
+  #   "\u00a0".blank? # => true
+  #
+  # @return [true, false]
   def blank?
-    self !~ /[^[:space:]]/
+    # 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
 
-class Numeric #:nodoc:
+class Numeric # :nodoc:
   # No number is blank:
   #
   #   1.blank? # => false
   #   0.blank? # => false
+  #
+  # @return [false]
+  def blank?
+    false
+  end
+end
+
+class Time # :nodoc:
+  # No Time is blank:
+  #
+  #   Time.now.blank? # => false
+  #
+  # @return [false]
   def blank?
     false
   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
@@ -8,8 +10,8 @@ class Object
   #   dup    = object.deep_dup
   #   dup.instance_variable_set(:@a, 1)
   #
-  #   object.instance_variable_defined?(:@a) #=> false
-  #   dup.instance_variable_defined?(:@a)    #=> true
+  #   object.instance_variable_defined?(:@a) # => false
+  #   dup.instance_variable_defined?(:@a)    # => true
   def deep_dup
     duplicable? ? dup : self
   end
@@ -22,10 +24,10 @@ class Array
   #   dup   = array.deep_dup
   #   dup[1][2] = 4
   #
-  #   array[1][2] #=> nil
-  #   dup[1][2]   #=> 4
+  #   array[1][2] # => nil
+  #   dup[1][2]   # => 4
   def deep_dup
-    map { |it| it.deep_dup }
+    map(&:deep_dup)
   end
 end
 
@@ -36,11 +38,18 @@ class Hash
   #   dup  = hash.deep_dup
   #   dup[:a][:c] = 'c'
   #
-  #   hash[:a][:c] #=> nil
-  #   dup[:a][:c]  #=> "c"
+  #   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 ::String === key || ::Symbol === 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,7 +1,9 @@
+# frozen_string_literal: true
+
 #--
-# Most objects are cloneable, but not all. For example you can't dup +nil+:
+# Most objects are cloneable, but not all. For example you can't dup methods:
 #
-#   nil.dup # => TypeError: can't dup NilClass
+#   method(:puts).dup # => TypeError: allocator undefined for Method
 #
 # Classes may signal their instances are not duplicable removing +dup+/+clone+
 # or raising exceptions from them. So, to dup an arbitrary object you normally
@@ -19,72 +21,40 @@
 class Object
   # Can you safely dup this object?
   #
-  # False for +nil+, +false+, +true+, symbol, and number objects;
+  # False for method objects;
   # true otherwise.
   def duplicable?
     true
   end
 end
 
-class NilClass
-  # +nil+ is not duplicable:
-  #
-  #   nil.duplicable? # => false
-  #   nil.dup         # => TypeError: can't dup NilClass
-  def duplicable?
-    false
-  end
-end
-
-class FalseClass
-  # +false+ is not duplicable:
+class Method
+  # Methods are not duplicable:
   #
-  #   false.duplicable? # => false
-  #   false.dup         # => TypeError: can't dup FalseClass
+  #  method(:puts).duplicable? # => false
+  #  method(:puts).dup         # => TypeError: allocator undefined for Method
   def duplicable?
     false
   end
 end
 
-class TrueClass
-  # +true+ is not duplicable:
+class UnboundMethod
+  # Unbound methods are not duplicable:
   #
-  #   true.duplicable? # => false
-  #   true.dup         # => TypeError: can't dup TrueClass
+  #  method(:puts).unbind.duplicable? # => false
+  #  method(:puts).unbind.dup         # => TypeError: allocator undefined for UnboundMethod
   def duplicable?
     false
   end
 end
 
-class Symbol
-  # Symbols are not duplicable:
-  #
-  #   :my_symbol.duplicable? # => false
-  #   :my_symbol.dup         # => TypeError: can't dup Symbol
-  def duplicable?
-    false
-  end
-end
+require "singleton"
 
-class Numeric
-  # Numbers are not duplicable:
+module Singleton
+  # Singleton instances are not duplicable:
   #
-  #  3.duplicable? # => false
-  #  3.dup         # => TypeError: can't dup Fixnum
+  # Class.new.include(Singleton).instance.dup # TypeError (can't dup instance of singleton
   def duplicable?
     false
   end
 end
-
-require 'bigdecimal'
-class BigDecimal
-  begin
-    BigDecimal.new('4.56').dup
-
-    def duplicable?
-      true
-    end
-  rescue TypeError
-    # can't dup, so use superclass implementation
-  end
-end

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

@@ -1,4 +1,4 @@
-require 'active_support/deprecation'
+# frozen_string_literal: true
 
 class Object
   # Returns true if this object is included in the argument. Argument must be
@@ -7,20 +7,23 @@ 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?(*args)
-    if args.length > 1
-      ActiveSupport::Deprecation.warn "Calling #in? with multiple arguments is" \
-        " deprecated, please pass in an object that responds to #include? instead."
-      args.include? self
-    else
-      another_object = args.first
-      if another_object.respond_to? :include?
-        another_object.include? self
-      else
-        raise ArgumentError.new 'The single parameter passed to #in? must respond to #include?'
-      end
-    end
+  def in?(another_object)
+    another_object.include?(self)
+  rescue NoMethodError
+    raise ArgumentError.new("The parameter passed to #in? must respond to #include?")
+  end
+
+  # Returns the receiver if it's included in the argument otherwise returns +nil+.
+  # Argument must be any object which responds to +#include?+. Usage:
+  #
+  #   params[:bucket_type].presence_in %w( project calendar )
+  #
+  # This will throw an +ArgumentError+ if the argument doesn't respond to +#include?+.
+  #
+  # @return [Object]
+  def presence_in(another_object)
+    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

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+# Hack to load json gem first so we can overwrite its to_json.
+require "json"
+require "bigdecimal"
+require "ipaddr"
+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,
+# otherwise they will always use to_json gem implementation, which is backwards incompatible in
+# several cases (for instance, the JSON implementation for Hash does not work) with inheritance.
+#
+# On the other hand, we should avoid conflict with ::JSON.{generate,dump}(obj). Unfortunately, the
+# JSON gem's encoder relies on its own to_json implementation to encode objects. Since it always
+# passes a ::JSON::State object as the only argument to to_json, we can detect that and forward the
+# calls to the original to_json method.
+#
+# It should be noted that when using ::JSON.{generate,dump} directly, ActiveSupport's encoder is
+# 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.
+
+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
+        super(options)
+      else
+        # to_json is being invoked directly, use ActiveSupport's encoder
+        ActiveSupport::JSON.encode(self, options)
+      end
+    end
+  end
+end
+
+[Enumerable, Object, Array, FalseClass, Float, Hash, Integer, NilClass, String, TrueClass].reverse_each do |klass|
+  klass.prepend(ActiveSupport::ToJsonWithActiveSupportEncoder)
+end
+
+class Module
+  def as_json(options = nil) # :nodoc:
+    name
+  end
+end
+
+class Object
+  def as_json(options = nil) # :nodoc:
+    if respond_to?(:to_hash)
+      to_hash.as_json(options)
+    else
+      instance_values.as_json(options)
+    end
+  end
+end
+
+class Struct # :nodoc:
+  def as_json(options = nil)
+    Hash[members.zip(values)].as_json(options)
+  end
+end
+
+class TrueClass
+  def as_json(options = nil) # :nodoc:
+    self
+  end
+end
+
+class FalseClass
+  def as_json(options = nil) # :nodoc:
+    self
+  end
+end
+
+class NilClass
+  def as_json(options = nil) # :nodoc:
+    self
+  end
+end
+
+class String
+  def as_json(options = nil) # :nodoc:
+    self
+  end
+end
+
+class Symbol
+  def as_json(options = nil) # :nodoc:
+    to_s
+  end
+end
+
+class Numeric
+  def as_json(options = nil) # :nodoc:
+    self
+  end
+end
+
+class Float
+  # Encoding Infinity or NaN to JSON should return "null". The default returns
+  # "Infinity" or "NaN" which are not valid JSON.
+  def as_json(options = nil) # :nodoc:
+    finite? ? self : nil
+  end
+end
+
+class BigDecimal
+  # A BigDecimal would be naturally represented as a JSON number. Most libraries,
+  # however, parse non-integer JSON numbers directly as floats. Clients using
+  # those libraries would get in general a wrong number and no way to recover
+  # other than manually inspecting the string with the JSON code itself.
+  #
+  # That's why a JSON string is returned. The JSON literal is not numeric, but
+  # if the other end knows by contract that the data is supposed to be a
+  # BigDecimal, it still has the chance to post-process the string and get the
+  # real value.
+  def as_json(options = nil) # :nodoc:
+    finite? ? to_s : nil
+  end
+end
+
+class Regexp
+  def as_json(options = nil) # :nodoc:
+    to_s
+  end
+end
+
+module Enumerable
+  def as_json(options = nil) # :nodoc:
+    to_a.as_json(options)
+  end
+end
+
+class IO
+  def as_json(options = nil) # :nodoc:
+    to_s
+  end
+end
+
+class Range
+  def as_json(options = nil) # :nodoc:
+    to_s
+  end
+end
+
+class Array
+  def as_json(options = nil) # :nodoc:
+    map { |v| options ? v.as_json(options.dup) : v.as_json }
+  end
+end
+
+class Hash
+  def as_json(options = nil) # :nodoc:
+    # create a subset of the hash by applying :only or :except
+    subset = if options
+      if attrs = options[:only]
+        slice(*Array(attrs))
+      elsif attrs = options[:except]
+        except(*Array(attrs))
+      else
+        self
+      end
+    else
+      self
+    end
+
+    result = {}
+    subset.each do |k, v|
+      result[k.to_s] = options ? v.as_json(options.dup) : v.as_json
+    end
+    result
+  end
+end
+
+class Time
+  def as_json(options = nil) # :nodoc:
+    if ActiveSupport::JSON::Encoding.use_standard_json_time_format
+      xmlschema(ActiveSupport::JSON::Encoding.time_precision)
+    else
+      %(#{strftime("%Y/%m/%d %H:%M:%S")} #{formatted_offset(false)})
+    end
+  end
+end
+
+class Date
+  def as_json(options = nil) # :nodoc:
+    if ActiveSupport::JSON::Encoding.use_standard_json_time_format
+      strftime("%Y-%m-%d")
+    else
+      strftime("%Y/%m/%d")
+    end
+  end
+end
+
+class DateTime
+  def as_json(options = nil) # :nodoc:
+    if ActiveSupport::JSON::Encoding.use_standard_json_time_format
+      xmlschema(ActiveSupport::JSON::Encoding.time_precision)
+    else
+      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 IPAddr # :nodoc:
+  def as_json(options = nil)
+    to_s
+  end
+end
+
+class Process::Status # :nodoc:
+  def as_json(options = nil)
+    { 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"