activesupport 4.0.13 → 4.1.0.beta1

data/lib/active_support/core_ext/module/introspection.rb

@@ -59,20 +59,4 @@ class Module
   def local_constants #:nodoc:
     constants(false)
   end
-
-  # *DEPRECATED*: Use +local_constants+ instead.
-  #
-  # Returns the names of the constants defined locally as strings.
-  #
-  #   module M
-  #     X = 1
-  #   end
-  #   M.local_constant_names # => ["X"]
-  #
-  # This method is useful for forward compatibility, since Ruby 1.8 returns
-  # constant names as strings, whereas 1.9 returns them as symbols.
-  def local_constant_names
-    ActiveSupport::Deprecation.warn 'Module#local_constant_names is deprecated, use Module#local_constants instead'
-    local_constants.map { |c| c.to_s }
-  end
 end

data/lib/active_support/core_ext/module/method_transplanting.rb

@@ -0,0 +1,11 @@
+class Module
+  ###
+  # TODO: remove this after 1.9 support is dropped
+  def methods_transplantable? # :nodoc:
+    x = Module.new { def foo; end }
+    Module.new { define_method :bar, x.instance_method(:foo) }
+    true
+  rescue TypeError
+    false
+  end
+end

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

@@ -63,6 +63,7 @@ class Numeric
 
   # Reads best without arguments:  10.minutes.ago
   def ago(time = ::Time.current)
+    ActiveSupport::Deprecation.warn "Calling #ago or #until on a number (e.g. 5.ago) is deprecated and will be removed in the future, use 5.seconds.ago instead"
     time - self
   end
 
@@ -71,9 +72,16 @@ class Numeric
 
   # Reads best with argument:  10.minutes.since(time)
   def since(time = ::Time.current)
+    ActiveSupport::Deprecation.warn "Calling #since or #from_now on a number (e.g. 5.since) is deprecated and will be removed in the future, use 5.seconds.since instead"
     time + self
   end
 
   # Reads best without arguments:  10.minutes.from_now
   alias :from_now :since
+
+  # Used with the standard time durations, like 1.hour.in_milliseconds -- 
+  # so we can feed them to JavaScript functions like getTime().
+  def in_milliseconds
+    self * 1000
+  end
 end

data/lib/active_support/core_ext/object.rb

@@ -8,7 +8,7 @@ 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'

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

@@ -90,7 +90,7 @@ class String
   #   '　'.blank?               # => true
   #   ' something here '.blank? # => false
   def blank?
-    self !~ /[^[:space:]]/
+    self =~ /\A[[:space:]]*\z/
   end
 end
 

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

@@ -8,8 +8,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,8 +22,8 @@ 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 }
   end
@@ -36,8 +36,8 @@ 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

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,9 @@ 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
 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.
+[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)
+      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.use_standard_json_time_format
+      xmlschema(3)
+    else
+      %(#{strftime("%Y/%m/%d %H:%M:%S")} #{formatted_offset(false)})
+    end
+  end
+end
+
+class Date
+  def as_json(options = nil) #:nodoc:
+    if ActiveSupport.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.use_standard_json_time_format
+      xmlschema(3)
+    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_json.rb

@@ -1,27 +1,5 @@
-# Hack to load json gem first so we can overwrite its to_json.
-begin
-  require 'json'
-rescue LoadError
-end
+ActiveSupport::Deprecation.warn 'You have required `active_support/core_ext/object/to_json`. ' \
+  'This file will be removed in Rails 4.2. You should require `active_support/core_ext/object/json` ' \
+  'instead.'
 
-# 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.
-[Object, Array, FalseClass, Float, Hash, Integer, NilClass, String, TrueClass].each do |klass|
-  klass.class_eval do
-    # Dumps object in JSON (JavaScript Object Notation). See www.json.org for more info.
-    def to_json(options = nil)
-      ActiveSupport::JSON.encode(self, options)
-    end
-  end
-end
-
-module Process
-  class Status
-    def as_json(options = nil)
-      { :exitstatus => exitstatus, :pid => pid }
-    end
-  end
-end
+require 'active_support/core_ext/object/json'

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

@@ -1 +1,58 @@
-require 'active_support/core_ext/object/to_query'
+class Object
+  # Alias of <tt>to_s</tt>.
+  def to_param
+    to_s
+  end
+end
+
+class NilClass
+  # Returns +self+.
+  def to_param
+    self
+  end
+end
+
+class TrueClass
+  # Returns +self+.
+  def to_param
+    self
+  end
+end
+
+class FalseClass
+  # Returns +self+.
+  def to_param
+    self
+  end
+end
+
+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 '/'
+  end
+end
+
+class Hash
+  # Returns a string representation of the receiver suitable for use as a URL
+  # query string:
+  #
+  #   {name: 'David', nationality: 'Danish'}.to_param
+  #   # => "name=David&nationality=Danish"
+  #
+  # An optional namespace can be passed to enclose the param names:
+  #
+  #   {name: 'David', nationality: 'Danish'}.to_param('user')
+  #   # => "user[name]=David&user[nationality]=Danish"
+  #
+  # The string pairs "key=value" that conform the query string
+  # are sorted lexicographically in ascending order.
+  #
+  # This method is also aliased as +to_query+.
+  def to_param(namespace = nil)
+    collect do |key, value|
+      value.to_query(namespace ? "#{namespace}[#{key}]" : key)
+    end.sort! * '&'
+  end
+end

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

@@ -1,45 +1,17 @@
-class Object
-  # Alias of <tt>to_s</tt>.
-  def to_param
-    to_s
-  end
+require 'active_support/core_ext/object/to_param'
 
-  # Converts an object into a string suitable for use as a URL query string,
-  # using the given <tt>key</tt> as the param name.
+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.
+  #
+  # Note: This method is defined as a default implementation for all Objects for Hash#to_query to work.
   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
 
-class NilClass
-  # Returns +self+.
-  def to_param
-    self
-  end
-end
-
-class TrueClass
-  # Returns +self+.
-  def to_param
-    self
-  end
-end
-
-class FalseClass
-  # Returns +self+.
-  def to_param
-    self
-  end
-end
-
 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 '/'
-  end
-
   # Converts an array into a string suitable for use as a URL query string,
   # using the given +key+ as the param name.
   #
@@ -51,26 +23,5 @@ class Array
 end
 
 class Hash
-  # Returns a string representation of the receiver suitable for use as a URL
-  # query string:
-  #
-  #   {name: 'David', nationality: 'Danish'}.to_query
-  #   # => "name=David&nationality=Danish"
-  #
-  # An optional namespace can be passed to enclose the param names:
-  #
-  #   {name: 'David', nationality: 'Danish'}.to_query('user')
-  #   # => "user[name]=David&user[nationality]=Danish"
-  #
-  # The string pairs "key=value" that conform the query string
-  # are sorted lexicographically in ascending order.
-  #
-  # 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 * '&'
-  end
-
-  alias_method :to_param, :to_query
+  alias_method :to_query, :to_param
 end