activesupport 4.1.16 → 4.2.0.beta1

data/lib/active_support/concern.rb

@@ -26,7 +26,7 @@ module ActiveSupport
   #       scope :disabled, -> { where(disabled: true) }
   #     end
   #
-  #     module ClassMethods
+  #     class_methods do
   #       ...
   #     end
   #   end
@@ -130,5 +130,13 @@ module ActiveSupport
         super
       end
     end
+
+    def class_methods(&class_methods_module_definition)
+      mod = const_defined?(:ClassMethods) ?
+        const_get(:ClassMethods) :
+        const_set(:ClassMethods, Module.new)
+
+      mod.module_eval(&class_methods_module_definition)
+    end
   end
 end

data/lib/active_support/core_ext/array/access.rb

@@ -5,6 +5,8 @@ class Array
   #   %w( a b c d ).from(2)  # => ["c", "d"]
   #   %w( a b c d ).from(10) # => []
   #   %w().from(0)           # => []
+  #   %w( a b c d ).from(-2) # => ["c", "d"]
+  #   %w( a b c ).from(-10)  # => []
   def from(position)
     self[position, length] || []
   end
@@ -15,8 +17,10 @@ class Array
   #   %w( a b c d ).to(2)  # => ["a", "b", "c"]
   #   %w( a b c d ).to(10) # => ["a", "b", "c", "d"]
   #   %w().to(0)           # => []
+  #   %w( a b c d ).to(-2) # => ["a", "b", "c"]
+  #   %w( a b c ).to(-10)  # => []
   def to(position)
-    first position + 1
+    self[0..position]
   end
 
   # Equal to <tt>self[1]</tt>.

data/lib/active_support/core_ext/array/grouping.rb

@@ -18,6 +18,11 @@ class Array
   #   ["3", "4"]
   #   ["5"]
   def in_groups_of(number, fill_with = nil)
+    if number.to_i <= 0
+      raise ArgumentError,
+        "Group size must be a positive integer, was #{number.inspect}"
+    end
+
     if fill_with == false
       collection = self
     else

data/lib/active_support/core_ext/class/delegating_attributes.rb

@@ -1,5 +1,7 @@
 require 'active_support/core_ext/kernel/singleton_class'
 require 'active_support/core_ext/module/remove_method'
+require 'active_support/core_ext/module/deprecation'
+
 
 class Class
   def superclass_delegating_accessor(name, options = {})
@@ -21,6 +23,8 @@ class Class
     end
   end
 
+  deprecate superclass_delegating_accessor: :class_attribute
+
   private
     # Take the object being set and store it in a method. This gives us automatic
     # inheritance behavior, without having to store the object in an instance

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

@@ -53,6 +53,16 @@ class DateTime
   # <tt>:months</tt>, <tt>:weeks</tt>, <tt>:days</tt>, <tt>:hours</tt>,
   # <tt>:minutes</tt>, <tt>:seconds</tt>.
   def advance(options)
+    unless options[:weeks].nil?
+      options[:weeks], partial_weeks = options[:weeks].divmod(1)
+      options[:days] = options.fetch(:days, 0) + 7 * partial_weeks
+    end
+
+    unless options[:days].nil?
+      options[:days], partial_days = options[:days].divmod(1)
+      options[:hours] = options.fetch(:hours, 0) + 24 * partial_days
+    end
+
     d = to_date.advance(options)
     datetime_advanced_by_date = change(:year => d.year, :month => d.month, :day => d.day)
     seconds_to_advance = \
@@ -63,7 +73,7 @@ class DateTime
     if seconds_to_advance.zero?
       datetime_advanced_by_date
     else
-      datetime_advanced_by_date.since seconds_to_advance
+      datetime_advanced_by_date.since(seconds_to_advance)
     end
   end
 

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

@@ -71,9 +71,9 @@ class DateTime
     civil(year, month, day, hour, min, sec, offset)
   end
 
-  # Converts +self+ to a floating-point number of seconds since the Unix epoch.
+  # Converts +self+ to a floating-point number of seconds, including fractional microseconds, since the Unix epoch.
   def to_f
-    seconds_since_unix_epoch.to_f
+    seconds_since_unix_epoch.to_f + sec_fraction
   end
 
   # Converts +self+ to an integer number of seconds since the Unix epoch.

data/lib/active_support/core_ext/digest/uuid.rb

@@ -0,0 +1,51 @@
+require 'securerandom'
+
+module Digest
+  module UUID
+    DNS_NAMESPACE  = "k\xA7\xB8\x10\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" #:nodoc:
+    URL_NAMESPACE  = "k\xA7\xB8\x11\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" #:nodoc:
+    OID_NAMESPACE  = "k\xA7\xB8\x12\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" #:nodoc:
+    X500_NAMESPACE = "k\xA7\xB8\x14\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" #:nodoc:
+
+    # Generates a v5 non-random UUID (Universally Unique IDentifier).
+    #
+    # Using Digest::MD5 generates version 3 UUIDs; Digest::SHA1 generates version 5 UUIDs.
+    # uuid_from_hash always generates the same UUID for a given name and namespace combination.
+    #
+    # See RFC 4122 for details of UUID at: http://www.ietf.org/rfc/rfc4122.txt
+    def self.uuid_from_hash(hash_class, uuid_namespace, name)
+      if hash_class == Digest::MD5
+        version = 3
+      elsif hash_class == Digest::SHA1
+        version = 5
+      else
+        raise ArgumentError, "Expected Digest::SHA1 or Digest::MD5, got #{hash_class.name}."
+      end
+
+      hash = hash_class.new
+      hash.update(uuid_namespace)
+      hash.update(name)
+
+      ary = hash.digest.unpack('NnnnnN')
+      ary[2] = (ary[2] & 0x0FFF) | (version << 12)
+      ary[3] = (ary[3] & 0x3FFF) | 0x8000
+
+      "%08x-%04x-%04x-%04x-%04x%08x" % ary
+    end
+
+    # Convenience method for uuid_from_hash using Digest::MD5.
+    def self.uuid_v3(uuid_namespace, name)
+      self.uuid_from_hash(Digest::MD5, uuid_namespace, name)
+    end
+
+    # Convenience method for uuid_from_hash using Digest::SHA1.
+    def self.uuid_v5(uuid_namespace, name)
+      self.uuid_from_hash(Digest::SHA1, uuid_namespace, name)
+    end
+
+    # Convenience method for SecureRandom.uuid.
+    def self.uuid_v4
+      SecureRandom.uuid
+    end
+  end
+end

data/lib/active_support/core_ext/hash.rb

@@ -6,3 +6,4 @@ require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/core_ext/hash/keys'
 require 'active_support/core_ext/hash/reverse_merge'
 require 'active_support/core_ext/hash/slice'
+require 'active_support/core_ext/hash/transform_values'

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

@@ -105,7 +105,7 @@ class Hash
     #   hash = Hash.from_xml(xml)
     #   # => {"hash"=>{"foo"=>1, "bar"=>2}}
     #
-    # DisallowedType is raised if the XML contains attributes with <tt>type="yaml"</tt> or
+    # +DisallowedType+ is raised if the XML contains attributes with <tt>type="yaml"</tt> or
     # <tt>type="symbol"</tt>. Use <tt>Hash.from_trusted_xml</tt> to parse this XML.
     def from_xml(xml, disallowed_types = nil)
       ActiveSupport::XMLConverter.new(xml, disallowed_types).to_h
@@ -221,7 +221,7 @@ module ActiveSupport
       def garbage?(value)
         # If the type is the only element which makes it then
         # this still makes the value nil, except if type is
-        # a XML node(where type['value'] is a Hash)
+        # an XML node(where type['value'] is a Hash)
         value['type'] && !value['type'].is_a?(::Hash) && value.size == 1
       end
 
@@ -241,4 +241,3 @@ module ActiveSupport
 
   end
 end
-

data/lib/active_support/core_ext/hash/indifferent_access.rb

@@ -18,6 +18,6 @@ class Hash
   #
   #   b = { b: 1 }
   #   { a: b }.with_indifferent_access['a'] # calls b.nested_under_indifferent_access
-  #   # => {"b"=>32}
+  #   # => {"b"=>1}
   alias nested_under_indifferent_access with_indifferent_access
 end

data/lib/active_support/core_ext/hash/keys.rb

@@ -6,7 +6,8 @@ class Hash
   #  hash.transform_keys{ |key| key.to_s.upcase }
   #  # => {"NAME"=>"Rob", "AGE"=>"28"}
   def transform_keys
-    result = {}
+    return enum_for(:transform_keys) unless block_given?
+    result = self.class.new
     each_key do |key|
       result[yield(key)] = self[key]
     end
@@ -16,6 +17,7 @@ class Hash
   # Destructively convert all keys using the block operations.
   # Same as transform_keys but modifies +self+.
   def transform_keys!
+    return enum_for(:transform_keys!) unless block_given?
     keys.each do |key|
       self[yield(key)] = delete(key)
     end
@@ -27,7 +29,7 @@ class Hash
   #   hash = { name: 'Rob', age: '28' }
   #
   #   hash.stringify_keys
-  #   # => { "name" => "Rob", "age" => "28" }
+  #   # => {"name"=>"Rob", "age"=>"28"}
   def stringify_keys
     transform_keys{ |key| key.to_s }
   end
@@ -44,7 +46,7 @@ class Hash
   #   hash = { 'name' => 'Rob', 'age' => '28' }
   #
   #   hash.symbolize_keys
-  #   # => { name: "Rob", age: "28" }
+  #   # => {:name=>"Rob", :age=>"28"}
   def symbolize_keys
     transform_keys{ |key| key.to_sym rescue key }
   end
@@ -57,9 +59,11 @@ class Hash
   end
   alias_method :to_options!, :symbolize_keys!
 
-  # Validate all keys in a hash match <tt>*valid_keys</tt>, raising ArgumentError
-  # on a mismatch. Note that keys are NOT treated indifferently, meaning if you
-  # use strings for keys but assert symbols as keys, this will fail.
+  # Validate all keys in a hash match <tt>*valid_keys</tt>, raising
+  # ArgumentError on a mismatch.
+  #
+  # Note that keys are treated differently than HashWithIndifferentAccess,
+  # meaning that string and symbol keys will not match.
   #
   #   { name: 'Rob', years: '28' }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key: :years. Valid keys are: :name, :age"
   #   { name: 'Rob', age: '28' }.assert_valid_keys('name', 'age') # => raises "ArgumentError: Unknown key: :name. Valid keys are: 'name', 'age'"

data/lib/active_support/core_ext/hash/transform_values.rb

@@ -0,0 +1,23 @@
+class Hash
+  # Returns a new hash with the results of running +block+ once for every value.
+  # The keys are unchanged.
+  #
+  #   { a: 1, b: 2, c: 3 }.transform_values { |x| x * 2 }
+  #   # => { a: 2, b: 4, c: 6 }
+  def transform_values
+    return enum_for(:transform_values) unless block_given?
+    result = self.class.new
+    each do |key, value|
+      result[key] = yield(value)
+    end
+    result
+  end
+
+  # Destructive +transform_values+
+  def transform_values!
+    return enum_for(:transform_values!) unless block_given?
+    each do |key, value|
+      self[key] = yield(value)
+    end
+  end
+end

data/lib/active_support/core_ext/kernel.rb

@@ -1,4 +1,5 @@
-require 'active_support/core_ext/kernel/reporting'
 require 'active_support/core_ext/kernel/agnostics'
-require 'active_support/core_ext/kernel/debugger'
+require 'active_support/core_ext/kernel/concern'
+require 'active_support/core_ext/kernel/debugger' if RUBY_VERSION < '2.0.0'
+require 'active_support/core_ext/kernel/reporting'
 require 'active_support/core_ext/kernel/singleton_class'

data/lib/active_support/core_ext/kernel/concern.rb

@@ -0,0 +1,10 @@
+require 'active_support/core_ext/module/concerning'
+
+module Kernel
+  # A shortcut to define a toplevel concern, not within a module.
+  #
+  # See Module::Concerning for more.
+  def concern(topic, &module_definition)
+    Object.concern topic, &module_definition
+  end
+end

data/lib/active_support/core_ext/kernel/reporting.rb

@@ -31,9 +31,13 @@ module Kernel
 
   # For compatibility
   def silence_stderr #:nodoc:
+    ActiveSupport::Deprecation.warn(
+      "#silence_stderr is deprecated and will be removed in the next release"
+    ) #not thread-safe
     silence_stream(STDERR) { yield }
   end
 
+  # Deprecated : this method is not thread safe
   # Silences any stream for the duration of the block.
   #
   #   silence_stream(STDOUT) do
@@ -41,6 +45,8 @@ module Kernel
   #   end
   #
   #   puts 'But this will'
+  #
+  # This method is not thread-safe.
   def silence_stream(stream)
     old_stream = stream.dup
     stream.reopen(RbConfig::CONFIG['host_os'] =~ /mswin|mingw/ ? 'NUL:' : '/dev/null')
@@ -80,6 +86,9 @@ module Kernel
   #   stream = capture(:stderr) { system('echo error 1>&2') }
   #   stream # => "error\n"
   def capture(stream)
+    ActiveSupport::Deprecation.warn(
+      "#capture(stream) is deprecated and will be removed in the next release"
+    ) #not thread-safe
     stream = stream.to_s
     captured_stream = Tempfile.new(stream)
     stream_io = eval("$#{stream}")
@@ -100,7 +109,12 @@ module Kernel
   # Silences both STDOUT and STDERR, even for subprocesses.
   #
   #   quietly { system 'bundle install' }
+  #
+  # This method is not thread-safe.
   def quietly
+    ActiveSupport::Deprecation.warn(
+      "#quietly is deprecated and will be removed in the next release"
+    ) #not thread-safe
     silence_stream(STDOUT) do
       silence_stream(STDERR) do
         yield

data/lib/active_support/core_ext/load_error.rb

@@ -7,6 +7,7 @@ class LoadError
   ]
 
   unless method_defined?(:path)
+    # Returns the path which was unable to be loaded.
     def path
       @path ||= begin
         REGEXPS.find do |regex|
@@ -17,9 +18,11 @@ class LoadError
     end
   end
 
+  # Returns true if the given path name (except perhaps for the ".rb"
+  # extension) is the missing file which caused the exception to be raised.
   def is_missing?(location)
     location.sub(/\.rb$/, '') == path.sub(/\.rb$/, '')
   end
 end
 
-MissingSourceFile = LoadError
+MissingSourceFile = LoadError

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

@@ -170,38 +170,26 @@ class Module
       # methods still accept two arguments.
       definition = (method =~ /[^\]]=$/) ? 'arg' : '*args, &block'
 
-      # The following generated methods call the target exactly once, storing
+      # The following generated method calls the target exactly once, storing
       # the returned value in a dummy variable.
       #
       # Reason is twofold: On one hand doing less calls is in general better.
       # On the other hand it could be that the target has side-effects,
       # whereas conceptually, from the user point of view, the delegator should
       # be doing one call.
-      if allow_nil
-        method_def = [
-          "def #{method_prefix}#{method}(#{definition})",  # def customer_name(*args, &block)
-          "_ = #{to}",                                     #   _ = client
-          "if !_.nil? || nil.respond_to?(:#{method})",     #   if !_.nil? || nil.respond_to?(:name)
-          "  _.#{method}(#{definition})",                  #     _.name(*args, &block)
-          "end",                                           #   end
-        "end"                                              # end
-        ].join ';'
-      else
-        exception = %(raise DelegationError, "#{self}##{method_prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
 
-        method_def = [
-          "def #{method_prefix}#{method}(#{definition})",  # def customer_name(*args, &block)
-          " _ = #{to}",                                    #   _ = client
-          "  _.#{method}(#{definition})",                  #   _.name(*args, &block)
-          "rescue NoMethodError => e",                     # rescue NoMethodError => e
-          "  if _.nil? && e.name == :#{method}",           #   if _.nil? && e.name == :name
-          "    #{exception}",                              #     # add helpful message to the exception
-          "  else",                                        #   else
-          "    raise",                                     #     raise
-          "  end",                                         #   end
-          "end"                                            # end
-        ].join ';'
-      end
+      exception = %(raise DelegationError, "#{self}##{method_prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
+
+      method_def = [
+        "def #{method_prefix}#{method}(#{definition})",
+        "  _ = #{to}",
+        "  if !_.nil? || nil.respond_to?(:#{method})",
+        "    _.#{method}(#{definition})",
+        "  else",
+        "    #{exception unless allow_nil}",
+        "  end",
+        "end"
+      ].join ';'
 
       module_eval(method_def, file, line)
     end

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

@@ -61,25 +61,7 @@ class Numeric
   end
   alias :fortnight :fortnights
 
-  # 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
-
-  # Reads best with argument:  10.minutes.until(time)
-  alias :until :ago
-
-  # 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 -- 
+  # 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

data/lib/active_support/core_ext/object.rb

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