activesupport 3.2.22.5 → 4.0.0

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

@@ -1,21 +1,26 @@
+require 'active_support/duration'
+require 'active_support/core_ext/numeric/time'
+
 class Integer
-  # Enables the use of time calculations and declarations, like 45.minutes + 2.hours + 4.years.
+  # Enables the use of time calculations and declarations, like <tt>45.minutes +
+  # 2.hours + 4.years</tt>.
   #
-  # These methods use Time#advance for precise date calculations when using from_now, ago, etc.
-  # as well as adding or subtracting their results from a Time object. For example:
+  # These methods use Time#advance for precise date calculations when using
+  # <tt>from_now</tt>, +ago+, etc. as well as adding or subtracting their
+  # results from a Time object.
   #
-  #   # equivalent to Time.now.advance(:months => 1)
+  #   # equivalent to Time.now.advance(months: 1)
   #   1.month.from_now
   #
-  #   # equivalent to Time.now.advance(:years => 2)
+  #   # equivalent to Time.now.advance(years: 2)
   #   2.years.from_now
   #
-  #   # equivalent to Time.now.advance(:months => 4, :years => 5)
+  #   # equivalent to Time.now.advance(months: 4, years: 5)
   #   (4.months + 5.years).from_now
   #
-  # While these methods provide precise calculation when used as in the examples above, care
-  # should be taken to note that this is not true if the result of `months', `years', etc is
-  # converted before use:
+  # While these methods provide precise calculation when used as in the examples
+  # above, care should be taken to note that this is not true if the result of
+  # +months+, +years+, etc is converted before use:
   #
   #   # equivalent to 30.days.to_i.from_now
   #   1.month.to_i.from_now
@@ -24,9 +29,9 @@ class Integer
   #   1.year.to_f.from_now
   #
   # In such cases, Ruby's core
-  # Date[http://stdlib.rubyonrails.org/libdoc/date/rdoc/index.html] and
-  # Time[http://stdlib.rubyonrails.org/libdoc/time/rdoc/index.html] should be used for precision
-  # date and time arithmetic
+  # Date[http://ruby-doc.org/stdlib/libdoc/date/rdoc/Date.html] and
+  # Time[http://ruby-doc.org/stdlib/libdoc/time/rdoc/Time.html] should be used for precision
+  # date and time arithmetic.
   def months
     ActiveSupport::Duration.new(self * 30.days, [[:months, self]])
   end

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

@@ -1,8 +1,8 @@
 module Kernel
   unless respond_to?(:debugger)
-    # Starts a debugging session if ruby-debug has been loaded (call rails server --debugger to do load it).
+    # Starts a debugging session if the +debugger+ gem has been loaded (call rails server --debugger to do load it).
     def debugger
-      message = "\n***** Debugger requested, but was not available (ensure ruby-debug is listed in Gemfile/installed as gem): Start server with --debugger to enable *****\n"
+      message = "\n***** Debugger requested, but was not available (ensure the debugger gem is listed in Gemfile/installed as gem): Start server with --debugger to enable *****\n"
       defined?(Rails) ? Rails.logger.info(message) : $stderr.puts(message)
     end
     alias breakpoint debugger unless respond_to?(:breakpoint)

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

@@ -1,8 +1,9 @@
 require 'rbconfig'
-require 'stringio'
+require 'tempfile'
 
 module Kernel
-  # Sets $VERBOSE to nil for the duration of the block and back to its original value afterwards.
+  # Sets $VERBOSE to nil for the duration of the block and back to its original
+  # value afterwards.
   #
   #   silence_warnings do
   #     value = noisy_call # no warning voiced
@@ -13,12 +14,14 @@ module Kernel
     with_warnings(nil) { yield }
   end
 
-  # Sets $VERBOSE to true for the duration of the block and back to its original value afterwards.
+  # Sets $VERBOSE to +true+ for the duration of the block and back to its
+  # original value afterwards.
   def enable_warnings
     with_warnings(true) { yield }
   end
 
-  # Sets $VERBOSE for the duration of the block and back to its original value afterwards.
+  # Sets $VERBOSE for the duration of the block and back to its original
+  # value afterwards.
   def with_warnings(flag)
     old_verbose, $VERBOSE = $VERBOSE, flag
     yield
@@ -51,40 +54,51 @@ module Kernel
   #
   #   suppress(ZeroDivisionError) do
   #     1/0
-  #     puts "This code is NOT reached"
+  #     puts 'This code is NOT reached'
   #   end
   #
-  #   puts "This code gets executed and nothing related to ZeroDivisionError was seen"
+  #   puts 'This code gets executed and nothing related to ZeroDivisionError was seen'
   def suppress(*exception_classes)
-    begin yield
-    rescue Exception => e
-      raise unless exception_classes.any? { |cls| e.kind_of?(cls) }
-    end
+    yield
+  rescue Exception => e
+    raise unless exception_classes.any? { |cls| e.kind_of?(cls) }
   end
 
   # Captures the given stream and returns it:
   #
-  #   stream = capture(:stdout) { puts "Cool" }
-  #   stream # => "Cool\n"
+  #   stream = capture(:stdout) { puts 'notice' }
+  #   stream # => "notice\n"
+  #
+  #   stream = capture(:stderr) { warn 'error' }
+  #   stream # => "error\n"
+  #
+  # even for subprocesses:
+  #
+  #   stream = capture(:stdout) { system('echo notice') }
+  #   stream # => "notice\n"
   #
+  #   stream = capture(:stderr) { system('echo error 1>&2') }
+  #   stream # => "error\n"
   def capture(stream)
-    begin
-      stream = stream.to_s
-      eval "$#{stream} = StringIO.new"
-      yield
-      result = eval("$#{stream}").string
-    ensure
-      eval("$#{stream} = #{stream.upcase}")
-    end
+    stream = stream.to_s
+    captured_stream = Tempfile.new(stream)
+    stream_io = eval("$#{stream}")
+    origin_stream = stream_io.dup
+    stream_io.reopen(captured_stream)
+
+    yield
 
-    result
+    stream_io.rewind
+    return captured_stream.read
+  ensure
+    captured_stream.unlink
+    stream_io.reopen(origin_stream)
   end
   alias :silence :capture
 
   # Silences both STDOUT and STDERR, even for subprocesses.
   #
   #   quietly { system 'bundle install' }
-  #
   def quietly
     silence_stream(STDOUT) do
       silence_stream(STDERR) do

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

@@ -1,11 +1,4 @@
 module Kernel
-  # Returns the object's singleton class.
-  def singleton_class
-    class << self
-      self
-    end
-  end unless respond_to?(:singleton_class) # exists in 1.9.2
-
   # class_eval on an object acts like singleton_class.class_eval.
   def class_eval(*args, &block)
     singleton_class.class_eval(*args, &block)

data/lib/active_support/core_ext/load_error.rb

@@ -6,12 +6,14 @@ class LoadError
     /^cannot load such file -- (.+)$/i,
   ]
 
-  def path
-    @path ||= begin
-      REGEXPS.find do |regex|
-        message =~ regex
+  unless method_defined?(:path)
+    def path
+      @path ||= begin
+        REGEXPS.find do |regex|
+          message =~ regex
+        end
+        $1
       end
-      $1
     end
   end
 

data/lib/active_support/core_ext/logger.rb

@@ -1,5 +1,8 @@
 require 'active_support/core_ext/class/attribute_accessors'
 require 'active_support/deprecation'
+require 'active_support/logger_silence'
+
+ActiveSupport::Deprecation.warn 'this file is deprecated and will be removed'
 
 # Adds the 'around_level' method to Logger.
 class Logger #:nodoc:
@@ -29,34 +32,15 @@ require 'logger'
 #
 #   logger.datetime_format = "%Y-%m-%d"
 #
-# Note: This logger is deprecated in favor of ActiveSupport::BufferedLogger
+# Note: This logger is deprecated in favor of ActiveSupport::Logger
 class Logger
-  ##
-  # :singleton-method:
-  # Set to false to disable the silencer
-  cattr_accessor :silencer
-  self.silencer = true
-
-  # Silences the logger for the duration of the block.
-  def silence(temporary_level = Logger::ERROR)
-    if silencer
-      begin
-        old_logger_level, self.level = level, temporary_level
-        yield self
-      ensure
-        self.level = old_logger_level
-      end
-    else
-      yield self
-    end
-  end
-  deprecate :silence
+  include LoggerSilence
 
   alias :old_datetime_format= :datetime_format=
   # Logging date-time format (string passed to +strftime+). Ignored if the formatter
   # does not respond to datetime_format=.
-  def datetime_format=(datetime_format)
-    formatter.datetime_format = datetime_format if formatter.respond_to?(:datetime_format=)
+  def datetime_format=(format)
+    formatter.datetime_format = format if formatter.respond_to?(:datetime_format=)
   end
 
   alias :old_datetime_format :datetime_format

data/lib/active_support/core_ext/marshal.rb

@@ -0,0 +1,21 @@
+require 'active_support/core_ext/module/aliasing'
+
+module Marshal
+  class << self
+    def load_with_autoloading(source)
+      load_without_autoloading(source)
+    rescue ArgumentError, NameError => exc
+      if exc.message.match(%r|undefined class/module (.+)|)
+        # try loading the class/module
+        $1.constantize
+        # if it is a IO we need to go back to read the object
+        source.rewind if source.respond_to?(:rewind)
+        retry
+      else
+        raise exc
+      end
+    end
+
+    alias_method_chain :load, :autoloading
+  end
+end

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

@@ -26,26 +26,25 @@ class Module
     aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
     yield(aliased_target, punctuation) if block_given?
 
-    with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}"
+    with_method = "#{aliased_target}_with_#{feature}#{punctuation}"
+    without_method = "#{aliased_target}_without_#{feature}#{punctuation}"
 
     alias_method without_method, target
     alias_method target, with_method
 
     case
-      when public_method_defined?(without_method)
-        public target
-      when protected_method_defined?(without_method)
-        protected target
-      when private_method_defined?(without_method)
-        private target
+    when public_method_defined?(without_method)
+      public target
+    when protected_method_defined?(without_method)
+      protected target
+    when private_method_defined?(without_method)
+      private target
     end
   end
 
   # Allows you to make aliases for attributes, which includes
   # getter, setter, and query methods.
   #
-  # Example:
-  #
   #   class Content < ActiveRecord::Base
   #     # has a title attribute
   #   end

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

@@ -1,5 +1,3 @@
-require 'active_support/core_ext/object/blank'
-
 class Module
   # A module may or may not have a name.
   #
@@ -7,7 +5,7 @@ class Module
   #   M.name # => "M"
   #
   #   m = Module.new
-  #   m.name # => ""
+  #   m.name # => nil
   #
   # A module gets a name when it is first assigned to a constant. Either
   # via the +module+ or +class+ keyword or by an explicit assignment:
@@ -15,10 +13,7 @@ class Module
   #   m = Module.new # creates an anonymous module
   #   M = m          # => m gets a name here as a side-effect
   #   m.name         # => "M"
-  #
   def anonymous?
-    # Uses blank? because the name of an anonymous class is an empty
-    # string in 1.8, and nil in 1.9.
-    name.blank?
+    name.nil?
   end
 end

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

@@ -15,7 +15,6 @@ class Module
     attr_internal_reader(*attrs)
     attr_internal_writer(*attrs)
   end
-
   alias_method :attr_internal, :attr_internal_accessor
 
   class << self; attr_accessor :attr_internal_naming_format end

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

@@ -4,6 +4,7 @@ class Module
   def mattr_reader(*syms)
     options = syms.extract_options!
     syms.each do |sym|
+      raise NameError.new('invalid attribute name') unless sym =~ /^[_A-Za-z]\w*$/
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
         @@#{sym} = nil unless defined? @@#{sym}
 
@@ -25,6 +26,7 @@ class Module
   def mattr_writer(*syms)
     options = syms.extract_options!
     syms.each do |sym|
+      raise NameError.new('invalid attribute name') unless sym =~ /^[_A-Za-z]\w*$/
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
         def self.#{sym}=(obj)
           @@#{sym} = obj
@@ -44,19 +46,19 @@ class Module
   # Extends the module object with module and instance accessors for class attributes,
   # just like the native attr* accessors for instance attributes.
   #
-  #  module AppConfiguration
-  #    mattr_accessor :google_api_key
-  #    self.google_api_key = "123456789"
+  #   module AppConfiguration
+  #     mattr_accessor :google_api_key
   #
-  #    mattr_accessor :paypal_url
-  #    self.paypal_url = "www.sandbox.paypal.com"
-  #  end
+  #     self.google_api_key = "123456789"
+  #   end
   #
-  #  AppConfiguration.google_api_key = "overriding the api key!"
+  #   AppConfiguration.google_api_key # => "123456789"
+  #   AppConfiguration.google_api_key = "overriding the api key!"
+  #   AppConfiguration.google_api_key # => "overriding the api key!"
   #
-  # To opt out of the instance writer method, pass :instance_writer => false.
-  # To opt out of the instance reader method, pass :instance_reader => false.
-  # To opt out of both instance methods, pass :instance_accessor => false.
+  # To opt out of the instance writer method, pass <tt>instance_writer: false</tt>.
+  # To opt out of the instance reader method, pass <tt>instance_reader: false</tt>.
+  # To opt out of both instance methods, pass <tt>instance_accessor: false</tt>.
   def mattr_accessor(*syms)
     mattr_reader(*syms)
     mattr_writer(*syms)

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

@@ -1,24 +1,26 @@
 class Module
-  # Provides a delegate class method to easily expose contained objects' methods
-  # as your own. Pass one or more methods (specified as symbols or strings)
-  # and the name of the target object via the <tt>:to</tt> option (also a symbol
-  # or string). At least one method and the <tt>:to</tt> option are required.
+  # Provides a +delegate+ class method to easily expose contained objects'
+  # public methods as your own.
+  #
+  # The macro receives one or more method names (specified as symbols or
+  # strings) and the name of the target object via the <tt>:to</tt> option
+  # (also a symbol or string).
   #
   # Delegation is particularly useful with Active Record associations:
   #
   #   class Greeter < ActiveRecord::Base
   #     def hello
-  #       "hello"
+  #       'hello'
   #     end
   #
   #     def goodbye
-  #       "goodbye"
+  #       'goodbye'
   #     end
   #   end
   #
   #   class Foo < ActiveRecord::Base
   #     belongs_to :greeter
-  #     delegate :hello, :to => :greeter
+  #     delegate :hello, to: :greeter
   #   end
   #
   #   Foo.new.hello   # => "hello"
@@ -28,7 +30,7 @@ class Module
   #
   #   class Foo < ActiveRecord::Base
   #     belongs_to :greeter
-  #     delegate :hello, :goodbye, :to => :greeter
+  #     delegate :hello, :goodbye, to: :greeter
   #   end
   #
   #   Foo.new.goodbye # => "goodbye"
@@ -43,15 +45,27 @@ class Module
   #     def initialize
   #       @instance_array = [8,9,10,11]
   #     end
-  #     delegate :sum, :to => :CONSTANT_ARRAY
-  #     delegate :min, :to => :@@class_array
-  #     delegate :max, :to => :@instance_array
+  #     delegate :sum, to: :CONSTANT_ARRAY
+  #     delegate :min, to: :@@class_array
+  #     delegate :max, to: :@instance_array
   #   end
   #
   #   Foo.new.sum # => 6
   #   Foo.new.min # => 4
   #   Foo.new.max # => 11
   #
+  # It's also possible to delegate a method to the class by using +:class+:
+  #
+  #   class Foo
+  #     def self.hello
+  #       "world"
+  #     end
+  #
+  #     delegate :hello, to: :class
+  #   end
+  #
+  #   Foo.new.hello # => "world"
+  #
   # Delegates can optionally be prefixed using the <tt>:prefix</tt> option. If the value
   # is <tt>true</tt>, the delegate methods are prefixed with the name of the object being
   # delegated to.
@@ -59,10 +73,10 @@ class Module
   #   Person = Struct.new(:name, :address)
   #
   #   class Invoice < Struct.new(:client)
-  #     delegate :name, :address, :to => :client, :prefix => true
+  #     delegate :name, :address, to: :client, prefix: true
   #   end
   #
-  #   john_doe = Person.new("John Doe", "Vimmersvej 13")
+  #   john_doe = Person.new('John Doe', 'Vimmersvej 13')
   #   invoice = Invoice.new(john_doe)
   #   invoice.client_name    # => "John Doe"
   #   invoice.client_address # => "Vimmersvej 13"
@@ -70,49 +84,64 @@ class Module
   # It is also possible to supply a custom prefix.
   #
   #   class Invoice < Struct.new(:client)
-  #     delegate :name, :address, :to => :client, :prefix => :customer
+  #     delegate :name, :address, to: :client, prefix: :customer
   #   end
   #
   #   invoice = Invoice.new(john_doe)
-  #   invoice.customer_name    # => "John Doe"
-  #   invoice.customer_address # => "Vimmersvej 13"
+  #   invoice.customer_name    # => 'John Doe'
+  #   invoice.customer_address # => 'Vimmersvej 13'
+  #
+  # If the target is +nil+ and does not respond to the delegated method a
+  # +NoMethodError+ is raised, as with any other value. Sometimes, however, it
+  # makes sense to be robust to that situation and that is the purpose of the
+  # <tt>:allow_nil</tt> option: If the target is not +nil+, or it is and
+  # responds to the method, everything works as usual. But if it is +nil+ and
+  # does not respond to the delegated method, +nil+ is returned.
+  #
+  #   class User < ActiveRecord::Base
+  #     has_one :profile
+  #     delegate :age, to: :profile
+  #   end
+  #
+  #   User.new.age # raises NoMethodError: undefined method `age'
   #
-  # If the delegate object is +nil+ an exception is raised, and that happens
-  # no matter whether +nil+ responds to the delegated method. You can get a
-  # +nil+ instead with the +:allow_nil+ option.
+  # But if not having a profile yet is fine and should not be an error
+  # condition:
   #
-  #  class Foo
-  #    attr_accessor :bar
-  #    def initialize(bar = nil)
-  #      @bar = bar
-  #    end
-  #    delegate :zoo, :to => :bar
-  #  end
+  #   class User < ActiveRecord::Base
+  #     has_one :profile
+  #     delegate :age, to: :profile, allow_nil: true
+  #   end
+  #
+  #   User.new.age # nil
+  #
+  # Note that if the target is not +nil+ then the call is attempted regardless of the
+  # <tt>:allow_nil</tt> option, and thus an exception is still raised if said object
+  # does not respond to the method:
   #
-  #  Foo.new.zoo   # raises NoMethodError exception (you called nil.zoo)
+  #   class Foo
+  #     def initialize(bar)
+  #       @bar = bar
+  #     end
   #
-  #  class Foo
-  #    attr_accessor :bar
-  #    def initialize(bar = nil)
-  #      @bar = bar
-  #    end
-  #    delegate :zoo, :to => :bar, :allow_nil => true
-  #  end
+  #     delegate :name, to: :@bar, allow_nil: true
+  #   end
   #
-  #  Foo.new.zoo   # returns nil
+  #   Foo.new("Bar").name # raises NoMethodError: undefined method `name'
   #
   def delegate(*methods)
     options = methods.pop
     unless options.is_a?(Hash) && to = options[:to]
-      raise ArgumentError, "Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, :to => :greeter)."
+      raise ArgumentError, 'Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, to: :greeter).'
     end
-    prefix, to, allow_nil = options[:prefix], options[:to], options[:allow_nil]
 
-    if prefix == true && to.to_s =~ /^[^a-z_]/
-      raise ArgumentError, "Can only automatically set the delegation prefix when delegating to a method."
+    prefix, allow_nil = options.values_at(:prefix, :allow_nil)
+
+    if prefix == true && to =~ /^[^a-z_]/
+      raise ArgumentError, 'Can only automatically set the delegation prefix when delegating to a method.'
     end
 
-    method_prefix =
+    method_prefix = \
       if prefix
         "#{prefix == true ? to : prefix}_"
       else
@@ -122,25 +151,39 @@ class Module
     file, line = caller.first.split(':', 2)
     line = line.to_i
 
+    to = to.to_s
+    to = 'self.class' if to == 'class'
+
     methods.each do |method|
-      method = method.to_s
+      # Attribute writer methods only accept one argument. Makes sure []=
+      # methods still accept two arguments.
+      definition = (method =~ /[^\]]=$/) ? 'arg' : '*args, &block'
 
+      # The following generated methods call 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 conceptualy, from the user point of view, the delegator should
+      # be doing one call.
       if allow_nil
-        module_eval(<<-EOS, file, line - 2)
-          def #{method_prefix}#{method}(*args, &block)        # def customer_name(*args, &block)
-            if #{to} || #{to}.respond_to?(:#{method})         #   if client || client.respond_to?(:name)
-              #{to}.__send__(:#{method}, *args, &block)       #     client.__send__(:name, *args, &block)
+        module_eval(<<-EOS, file, line - 3)
+          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
         EOS
       else
         exception = %(raise "#{self}##{method_prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
 
-        module_eval(<<-EOS, file, line - 1)
-          def #{method_prefix}#{method}(*args, &block)        # def customer_name(*args, &block)
-            #{to}.__send__(:#{method}, *args, &block)         #   client.__send__(:name, *args, &block)
+        module_eval(<<-EOS, file, line - 2)
+          def #{method_prefix}#{method}(#{definition})        # def customer_name(*args, &block)
+            _ = #{to}                                         #   _ = client
+            _.#{method}(#{definition})                        #   _.name(*args, &block)
           rescue NoMethodError                                # rescue NoMethodError
-            if #{to}.nil?                                     #   if client.nil?
+            if _.nil?                                         #   if _.nil?
               #{exception}                                    #     # add helpful message to the exception
             else                                              #   else
               raise                                           #     raise

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

@@ -1,8 +1,24 @@
+require 'active_support/deprecation/method_wrappers'
+
 class Module
-  # Declare that a method has been deprecated.
   #   deprecate :foo
-  #   deprecate :bar => 'message'
-  #   deprecate :foo, :bar, :baz => 'warning!', :qux => 'gone!'
+  #   deprecate bar: 'message'
+  #   deprecate :foo, :bar, baz: 'warning!', qux: 'gone!'
+  #
+  # You can also use custom deprecator instance:
+  #
+  #   deprecate :foo, deprecator: MyLib::Deprecator.new
+  #   deprecate :foo, bar: "warning!", deprecator: MyLib::Deprecator.new
+  #
+  # \Custom deprecators must respond to <tt>deprecation_warning(deprecated_method_name, message, caller_backtrace)</tt>
+  # method where you can implement your custom warning behavior.
+  #
+  #   class MyLib::Deprecator
+  #     def deprecation_warning(deprecated_method_name, message, caller_backtrace = nil)
+  #        message = "#{deprecated_method_name} is deprecated and will be removed from MyLibrary | #{message}"
+  #        Kernel.warn message
+  #     end
+  #   end
   def deprecate(*method_names)
     ActiveSupport::Deprecation.deprecate_methods(self, *method_names)
   end