activesupport 4.0.13 → 4.2.11.3

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

@@ -1,7 +1,7 @@
 #--
-# 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,7 +19,7 @@
 class Object
   # Can you safely dup this object?
   #
-  # False for +nil+, +false+, +true+, symbol, and number objects;
+  # False for +nil+, +false+, +true+, symbol, number and BigDecimal(in 1.9.x) objects;
   # true otherwise.
   def duplicable?
     true
@@ -27,57 +27,86 @@ class Object
 end
 
 class NilClass
-  # +nil+ is not duplicable:
-  #
-  #   nil.duplicable? # => false
-  #   nil.dup         # => TypeError: can't dup NilClass
-  def duplicable?
-    false
+  begin
+    nil.dup
+  rescue TypeError
+
+    # +nil+ is not duplicable:
+    #
+    #   nil.duplicable? # => false
+    #   nil.dup         # => TypeError: can't dup NilClass
+    def duplicable?
+      false
+    end
   end
 end
 
 class FalseClass
-  # +false+ is not duplicable:
-  #
-  #   false.duplicable? # => false
-  #   false.dup         # => TypeError: can't dup FalseClass
-  def duplicable?
-    false
+  begin
+    false.dup
+  rescue TypeError
+
+    # +false+ is not duplicable:
+    #
+    #   false.duplicable? # => false
+    #   false.dup         # => TypeError: can't dup FalseClass
+    def duplicable?
+      false
+    end
   end
 end
 
 class TrueClass
-  # +true+ is not duplicable:
-  #
-  #   true.duplicable? # => false
-  #   true.dup         # => TypeError: can't dup TrueClass
-  def duplicable?
-    false
+  begin
+    true.dup
+  rescue TypeError
+
+    # +true+ is not duplicable:
+    #
+    #   true.duplicable? # => false
+    #   true.dup         # => TypeError: can't dup TrueClass
+    def duplicable?
+      false
+    end
   end
 end
 
 class Symbol
-  # Symbols are not duplicable:
-  #
-  #   :my_symbol.duplicable? # => false
-  #   :my_symbol.dup         # => TypeError: can't dup Symbol
-  def duplicable?
-    false
+  begin
+    :symbol.dup # Ruby 2.4.x.
+    'symbol_from_string'.to_sym.dup # Some symbols can't `dup` in Ruby 2.4.0.
+  rescue TypeError
+
+    # Symbols are not duplicable:
+    #
+    #   :my_symbol.duplicable? # => false
+    #   :my_symbol.dup         # => TypeError: can't dup Symbol
+    def duplicable?
+      false
+    end
   end
 end
 
 class Numeric
-  # Numbers are not duplicable:
-  #
-  #  3.duplicable? # => false
-  #  3.dup         # => TypeError: can't dup Fixnum
-  def duplicable?
-    false
+  begin
+    1.dup
+  rescue TypeError
+
+    # Numbers are not duplicable:
+    #
+    #  3.duplicable? # => false
+    #  3.dup         # => TypeError: can't dup Integer
+    def duplicable?
+      false
+    end
   end
 end
 
 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
 
@@ -88,3 +117,13 @@ class BigDecimal
     # can't dup, so use superclass implementation
   end
 end
+
+class Method
+  # Methods are not duplicable:
+  #
+  #  method(:puts).duplicable? # => false
+  #  method(:puts).dup         # => TypeError: allocator undefined for Method
+  def duplicable?
+    false
+  end
+end

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

@@ -1,5 +1,3 @@
-require 'active_support/deprecation'
-
 class Object
   # Returns true if this object is included in the argument. Argument must be
   # any object which responds to +#include?+. Usage:
@@ -9,18 +7,21 @@ class Object
   #
   # 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)
+    self.in?(another_object) ? self : nil
   end
 end

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

@@ -0,0 +1,15 @@
+class Object
+  # TODO: Remove this file when we drop support for Ruby < 2.2
+  unless respond_to?(:itself)
+    # Returns the object itself.
+    #
+    # Useful for chaining methods, such as Active Record scopes:
+    #
+    #   Event.public_send(state.presence_in([ :trashed, :drafted ]) || :itself).order(:created_at)
+    #
+    # @return Object
+    def itself
+      self
+    end
+  end
+end

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

@@ -0,0 +1,197 @@
+# 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'
+
+# 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
+# and consequently classes as ActiveSupport::OrderedHash cannot be serialized to json.
+#
+# 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.
+[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:
+      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)
+      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
+
+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 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
+
+    Hash[subset.map { |k, v| [k.to_s, options ? v.as_json(options.dup) : v.as_json] }]
+  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 Process::Status #:nodoc:
+  def as_json(options = nil)
+    { :exitstatus => exitstatus, :pid => pid }
+  end
+end

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

@@ -1,3 +1,5 @@
+require 'cgi'
+
 class Object
   # Alias of <tt>to_s</tt>.
   def to_param
@@ -7,7 +9,6 @@ class Object
   # Converts an object into a string suitable for use as a URL query string,
   # using the given <tt>key</tt> as the param name.
   def to_query(key)
-    require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
     "#{CGI.escape(key.to_param)}=#{CGI.escape(to_param.to_s)}"
   end
 end
@@ -46,7 +47,12 @@ class Array
   #   ['Rails', 'coding'].to_query('hobbies') # => "hobbies%5B%5D=Rails&hobbies%5B%5D=coding"
   def to_query(key)
     prefix = "#{key}[]"
-    collect { |value| value.to_query(prefix) }.join '&'
+
+    if empty?
+      nil.to_query(prefix)
+    else
+      collect { |value| value.to_query(prefix) }.join '&'
+    end
   end
 end
 
@@ -57,10 +63,10 @@ class Hash
   #   {name: 'David', nationality: 'Danish'}.to_query
   #   # => "name=David&nationality=Danish"
   #
-  # An optional namespace can be passed to enclose the param names:
+  # An optional namespace can be passed to enclose key names:
   #
   #   {name: 'David', nationality: 'Danish'}.to_query('user')
-  #   # => "user[name]=David&user[nationality]=Danish"
+  #   # => "user%5Bname%5D=David&user%5Bnationality%5D=Danish"
   #
   # The string pairs "key=value" that conform the query string
   # are sorted lexicographically in ascending order.
@@ -68,8 +74,10 @@ class Hash
   # This method is also aliased as +to_param+.
   def to_query(namespace = nil)
     collect do |key, value|
-      value.to_query(namespace ? "#{namespace}[#{key}]" : key)
-    end.sort * '&'
+      unless (value.is_a?(Hash) || value.is_a?(Array)) && value.empty?
+        value.to_query(namespace ? "#{namespace}[#{key}]" : key)
+      end
+    end.compact.sort! * '&'
   end
 
   alias_method :to_param, :to_query

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

@@ -9,7 +9,23 @@ class Object
   #
   # instead of
   #
-  #   @person ? @person.name : nil
+  #   @person.name if @person
+  #
+  # +try+ calls can be chained:
+  #
+  #   @person.try(:spouse).try(:name)
+  #
+  # instead of
+  #
+  #   @person.spouse.name if @person && @person.spouse
+  #
+  # +try+ will also return +nil+ if the receiver does not respond to the method:
+  #
+  #   @person.try(:non_existing_method) #=> nil
+  #
+  # instead of
+  #
+  #   @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:
@@ -24,7 +40,7 @@ class Object
   #
   # The number of arguments in the signature must match. If the object responds
   # to the method the call is attempted and +ArgumentError+ is still raised
-  # otherwise.
+  # in case of argument mismatch.
   #
   # If +try+ is called without arguments it yields the receiver to a given
   # block unless it is +nil+:
@@ -33,24 +49,30 @@ class Object
   #     ...
   #   end
   #
-  # Please also note that +try+ is defined on +Object+, therefore it won't work
+  # You can also call try with a block without accepting an argument, and the block
+  # will be instance_eval'ed instead:
+  #
+  #   @person.try { upcase.truncate(50) }
+  #
+  # 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
-  # delegator itself.
+  # the delegator itself.
   def try(*a, &b)
-    if a.empty? && block_given?
-      yield self
-    else
-      public_send(*a, &b) if respond_to?(a.first)
-    end
+    try!(*a, &b) if a.empty? || respond_to?(a.first)
   end
 
-  # Same as #try, but will raise a NoMethodError exception if the receiving is not nil and
-  # does not implemented the tried method.
+  # Same as #try, but will raise a NoMethodError exception if the receiver is not +nil+ and
+  # does not implement the tried method.
+
   def try!(*a, &b)
     if a.empty? && block_given?
-      yield self
+      if b.arity == 0
+        instance_eval(&b)
+      else
+        yield self
+      end
     else
       public_send(*a, &b)
     end
@@ -59,12 +81,12 @@ end
 
 class NilClass
   # Calling +try+ on +nil+ always returns +nil+.
-  # It becomes specially helpful when navigating through associations that may return +nil+.
+  # It becomes especially helpful when navigating through associations that may return +nil+.
   #
   #   nil.try(:name) # => nil
   #
   # Without +try+
-  #   @person && !@person.children.blank? && @person.children.first.name
+  #   @person && @person.children.any? && @person.children.first.name
   #
   # With +try+
   #   @person.try(:children).try(:first).try(:name)

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

@@ -34,9 +34,36 @@ class Object
   #     body    i18n.t :body, user_name: user.name
   #   end
   #
+  # When you don't pass an explicit receiver, it executes the whole block
+  # in merging options context:
+  #
+  #   class Account < ActiveRecord::Base
+  #     with_options dependent: :destroy do
+  #       has_many :customers
+  #       has_many :products
+  #       has_many :invoices
+  #       has_many :expenses
+  #     end
+  #   end
+  #
   # <tt>with_options</tt> can also be nested since the call is forwarded to its receiver.
-  # Each nesting level will merge inherited defaults in addition to their own.
-  def with_options(options)
-    yield ActiveSupport::OptionMerger.new(self, options)
+  #
+  # NOTE: Each nesting level will merge inherited defaults in addition to their own.
+  #
+  #   class Post < ActiveRecord::Base
+  #     with_options if: :persisted?, length: { minimum: 50 } do
+  #       validates :content, if: -> { content.present? }
+  #     end
+  #   end
+  #
+  # The code is equivalent to:
+  #
+  #   validates :content, length: { minimum: 50 }, if: -> { content.present? }
+  #
+  # Hence the inherited default for `if` key is ignored.
+  #
+  def with_options(options, &block)
+    option_merger = ActiveSupport::OptionMerger.new(self, options)
+    block.arity.zero? ? option_merger.instance_eval(&block) : block.call(option_merger)
   end
 end

data/lib/active_support/core_ext/object.rb

@@ -2,13 +2,14 @@ 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'
 
 require 'active_support/core_ext/object/conversions'
 require 'active_support/core_ext/object/instance_variables'
 
-require 'active_support/core_ext/object/to_json'
+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'