activesupport 4.0.0.beta1 → 4.0.0.rc1

data/lib/active_support/callbacks.rb

@@ -61,6 +61,8 @@ module ActiveSupport
       extend ActiveSupport::DescendantsTracker
     end
 
+    CALLBACK_FILTER_TYPES = [:before, :after, :around]
+
     # Runs the callbacks for the given event.
     #
     # Calls the before and around callbacks in the order they were set, yields
@@ -131,7 +133,13 @@ module ActiveSupport
       end
 
       def matches?(_kind, _filter)
-        @kind == _kind && @filter == _filter
+        if @_is_object_filter
+          _filter_matches = @filter.to_s.start_with?(_method_name_for_object_filter(_kind, _filter, false))
+        else
+          _filter_matches = (@filter == _filter) 
+        end
+
+        @kind == _kind && _filter_matches
       end
 
       def duplicates?(other)
@@ -234,6 +242,16 @@ module ActiveSupport
         @compiled_options = conditions.flatten.join(" && ")
       end
 
+      def _method_name_for_object_filter(kind, filter, append_next_id = true)
+        class_name = filter.kind_of?(Class) ? filter.to_s : filter.class.to_s
+        class_name.gsub!(/<|>|#/, '')
+        class_name.gsub!(/\/|:/, "_")
+
+        method_name = "_callback_#{kind}_#{class_name}"
+        method_name << "_#{next_id}" if append_next_id
+        method_name
+      end
+
       # Filters support:
       #
       #   Arrays::  Used in conditions. This is used to specify
@@ -255,7 +273,8 @@ module ActiveSupport
       #     a method is created that calls the before_foo method
       #     on the object.
       def _compile_filter(filter)
-        method_name = "_callback_#{@kind}_#{next_id}"
+        @_is_object_filter = false
+
         case filter
         when Array
           filter.map {|f| _compile_filter(f)}
@@ -264,11 +283,14 @@ module ActiveSupport
         when String
           "(#{filter})"
         when Proc
+          method_name = "_callback_#{@kind}_#{next_id}"
           @klass.send(:define_method, method_name, &filter)
           return method_name if filter.arity <= 0
 
           method_name << (filter.arity == 1 ? "(self)" : " self, Proc.new ")
         else
+          method_name = _method_name_for_object_filter(kind, filter)
+          @_is_object_filter = true
           @klass.send(:define_method, "#{method_name}_object") { filter }
 
           _normalize_legacy_filter(kind, filter)
@@ -314,14 +336,11 @@ module ActiveSupport
         @config = {
           :terminator => "false",
           :scope => [ :kind ]
-        }.merge(config)
+        }.merge!(config)
       end
 
       def compile
-        method = []
-        method << "value = nil"
-        method << "halted = false"
-
+        method =  ["value = nil", "halted = false"]
         callbacks = "value = !halted && (!block_given? || yield)"
         reverse_each do |callback|
           callbacks = callback.apply(callbacks)
@@ -395,7 +414,7 @@ module ActiveSupport
       # This is used internally to append, prepend and skip callbacks to the
       # CallbackChain.
       def __update_callbacks(name, filters = [], block = nil) #:nodoc:
-        type = [:before, :after, :around].include?(filters.first) ? filters.shift : :before
+        type = CALLBACK_FILTER_TYPES.include?(filters.first) ? filters.shift : :before
         options = filters.last.is_a?(Hash) ? filters.pop : {}
         filters.unshift(block) if block
 

data/lib/active_support/core_ext.rb

@@ -1,4 +1,4 @@
-Dir["#{File.dirname(__FILE__)}/core_ext/*.rb"].sort.each do |path|
+Dir["#{File.dirname(__FILE__)}/core_ext/*.rb"].each do |path|
   next if File.basename(path, '.rb') == 'logger'
-  require "active_support/core_ext/#{File.basename(path, '.rb')}"
+  require path
 end

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

@@ -12,7 +12,7 @@ class Array
   # pass an option key that doesn't exist in the list below, it will raise an
   # <tt>ArgumentError</tt>.
   #
-  # Options:
+  # ==== Options
   #
   # * <tt>:words_connector</tt> - The sign or word used to join the elements
   #   in arrays with two or more elements (default: ", ").
@@ -24,6 +24,8 @@ class Array
   #   the connector options defined on the 'support.array' namespace in the
   #   corresponding dictionary file.
   #
+  # ==== Examples
+  #
   #   [].to_sentence                      # => ""
   #   ['one'].to_sentence                 # => "one"
   #   ['one', 'two'].to_sentence          # => "one and two"
@@ -38,10 +40,10 @@ class Array
   #   ['one', 'two', 'three'].to_sentence(words_connector: ' or ', last_word_connector: ' or at least ')
   #   # => "one or two or at least three"
   #
-  # Examples using <tt>:locale</tt> option:
+  # Using <tt>:locale</tt> option:
   #
   #   # Given this locale dictionary:
-  #   # 
+  #   #
   #   #   es:
   #   #     support:
   #   #       array:

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

@@ -1,5 +1,5 @@
 class Array
-  # *DEPRECATED*: Use +Array#uniq+ instead.
+  # *DEPRECATED*: Use <tt>Array#uniq</tt> instead.
   #
   # Returns a unique array based on the criteria in the block.
   #
@@ -9,7 +9,7 @@ class Array
     uniq(&block)
   end
 
-  # *DEPRECATED*: Use +Array#uniq!+ instead.
+  # *DEPRECATED*: Use <tt>Array#uniq!</tt> instead.
   #
   # Same as +uniq_by+, but modifies +self+.
   def uniq_by!(&block)

data/lib/active_support/core_ext/benchmark.rb

@@ -1,6 +1,13 @@
 require 'benchmark'
 
 class << Benchmark
+  # Benchmark realtime in milliseconds.
+  #
+  #   Benchmark.realtime { User.all }
+  #   # => 8.0e-05
+  #
+  #   Benchmark.ms { User.all }
+  #   # => 0.074
   def ms
     1000 * realtime { yield }
   end

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

@@ -1,4 +1,5 @@
 require 'bigdecimal'
+require 'bigdecimal/util'
 require 'yaml'
 
 class BigDecimal

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

@@ -44,7 +44,8 @@ class Class
   #   Base.setting               # => []
   #   Subclass.setting           # => [:foo]
   #
-  # For convenience, a query method is defined as well:
+  # For convenience, an instance predicate method is defined as well.
+  # To skip it, pass <tt>instance_predicate: false</tt>.
   #
   #   Subclass.setting?       # => false
   #
@@ -72,43 +73,46 @@ class Class
     # double assignment is used to avoid "assigned but unused variable" warning
     instance_reader = instance_reader = options.fetch(:instance_accessor, true) && options.fetch(:instance_reader, true)
     instance_writer = options.fetch(:instance_accessor, true) && options.fetch(:instance_writer, true)
+    instance_predicate = options.fetch(:instance_predicate, true)
 
-    # We use class_eval here rather than define_method because class_attribute
-    # may be used in a performance sensitive context therefore the overhead that
-    # define_method introduces may become significant.
     attrs.each do |name|
-      class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def self.#{name}() nil end
-        def self.#{name}?() !!#{name} end
+      define_singleton_method(name) { nil }
+      define_singleton_method("#{name}?") { !!public_send(name) } if instance_predicate
 
-        def self.#{name}=(val)
-          singleton_class.class_eval do
-            remove_possible_method(:#{name})
-            define_method(:#{name}) { val }
-          end
+      ivar = "@#{name}"
+
+      define_singleton_method("#{name}=") do |val|
+        singleton_class.class_eval do
+          remove_possible_method(name)
+          define_method(name) { val }
+        end
 
-          if singleton_class?
-            class_eval do
-              remove_possible_method(:#{name})
-              def #{name}
-                defined?(@#{name}) ? @#{name} : singleton_class.#{name}
+        if singleton_class?
+          class_eval do
+            remove_possible_method(name)
+            define_method(name) do
+              if instance_variable_defined? ivar
+                instance_variable_get ivar
+              else
+                singleton_class.send name
               end
             end
           end
-          val
         end
+        val
+      end
 
-        if instance_reader
-          remove_possible_method :#{name}
-          def #{name}
-            defined?(@#{name}) ? @#{name} : self.class.#{name}
-          end
-
-          def #{name}?
-            !!#{name}
+      if instance_reader
+        remove_possible_method name
+        define_method(name) do
+          if instance_variable_defined?(ivar)
+            instance_variable_get ivar
+          else
+            self.class.public_send name
           end
         end
-      RUBY
+        define_method("#{name}?") { !!public_send(name) } if instance_predicate
+      end
 
       attr_writer name if instance_writer
     end

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

@@ -32,7 +32,7 @@ class Class
   def cattr_reader(*syms)
     options = syms.extract_options!
     syms.each do |sym|
-      raise NameError.new('invalid attribute name') unless sym =~ /^[_A-Za-z]\w*$/
+      raise NameError.new("invalid class attribute name: #{sym}") unless sym =~ /^[_A-Za-z]\w*$/
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
         unless defined? @@#{sym}
           @@#{sym} = nil
@@ -93,7 +93,7 @@ class Class
   def cattr_writer(*syms)
     options = syms.extract_options!
     syms.each do |sym|
-      raise NameError.new('invalid attribute name') unless sym =~ /^[_A-Za-z]\w*$/
+      raise NameError.new("invalid class attribute name: #{sym}") unless sym =~ /^[_A-Za-z]\w*$/
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
         unless defined? @@#{sym}
           @@#{sym} = nil

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

@@ -93,7 +93,7 @@ module DateAndTime
 
     # Returns a new date/time at the end of the quarter.
     # Example: 31st March, 30th June, 30th September.
-    # DateTIme objects will have a time set to 23:59:59.
+    # DateTime objects will have a time set to 23:59:59.
     def end_of_quarter
       last_quarter_month = [3, 6, 9, 12].detect { |m| m >= month }
       beginning_of_month.change(:month => last_quarter_month).end_of_month
@@ -109,11 +109,11 @@ module DateAndTime
     alias :at_beginning_of_year :beginning_of_year
 
     # Returns a new date/time representing the given day in the next week.
-    # Week is assumed to start on +start_day+, default is
-    # +Date.beginning_of_week+ or +config.beginning_of_week+ when set.
-    # DateTime objects have their time set to 0:00.
-    def next_week(start_day = Date.beginning_of_week)
-      first_hour{ weeks_since(1).beginning_of_week.days_since(days_span(start_day)) }
+    # The +given_day_in_next_week+ defaults to the beginning of the week
+    # which is determined by +Date.beginning_of_week+ or +config.beginning_of_week+
+    # when set. +DateTime+ objects have their time set to 0:00.
+    def next_week(given_day_in_next_week = Date.beginning_of_week)
+      first_hour{ weeks_since(1).beginning_of_week.days_since(days_span(given_day_in_next_week)) }
     end
 
     # Short-hand for months_since(1).

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

@@ -1,8 +1,10 @@
 class Module
-  # Provides a delegate class method to easily expose contained objects' public 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:
   #
@@ -89,29 +91,44 @@ class Module
   #   invoice.customer_name    # => 'John Doe'
   #   invoice.customer_address # => 'Vimmersvej 13'
   #
-  # 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.
+  # 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 Foo
-  #     attr_accessor :bar
-  #     def initialize(bar = nil)
-  #       @bar = bar
-  #     end
-  #     delegate :zoo, to: :bar
+  #   class User < ActiveRecord::Base
+  #     has_one :profile
+  #     delegate :age, to: :profile
   #   end
   #
-  #   Foo.new.zoo   # raises NoMethodError exception (you called nil.zoo)
+  #   User.new.age # raises NoMethodError: undefined method `age'
+  #
+  # But if not having a profile yet is fine and should not be an error
+  # condition:
+  #
+  #   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:
   #
   #   class Foo
-  #     attr_accessor :bar
-  #     def initialize(bar = nil)
+  #     def initialize(bar)
   #       @bar = bar
   #     end
-  #     delegate :zoo, to: :bar, allow_nil: true
+  #
+  #     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]
@@ -142,22 +159,31 @@ class Module
       # 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)
+        module_eval(<<-EOS, file, line - 3)
           def #{method_prefix}#{method}(#{definition})        # def customer_name(*args, &block)
-            if #{to} || #{to}.respond_to?(:#{method})         #   if client || client.respond_to?(:name)
-              #{to}.#{method}(#{definition})                  #     client.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)
+        module_eval(<<-EOS, file, line - 2)
           def #{method_prefix}#{method}(#{definition})        # def customer_name(*args, &block)
-            #{to}.#{method}(#{definition})                    #   client.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

@@ -14,8 +14,8 @@ class Module
   # method where you can implement your custom warning behavior.
   #
   #   class MyLib::Deprecator
-  #     def deprecation_warning(deprecated_method_name, message, caller_backtrace)
-  #        message = "#{method_name} is deprecated and will be removed from MyLibrary | #{message}"
+  #     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

data/lib/active_support/core_ext/string.rb

@@ -4,7 +4,6 @@ require 'active_support/core_ext/string/multibyte'
 require 'active_support/core_ext/string/starts_ends_with'
 require 'active_support/core_ext/string/inflections'
 require 'active_support/core_ext/string/access'
-require 'active_support/core_ext/string/xchar'
 require 'active_support/core_ext/string/behavior'
 require 'active_support/core_ext/string/output_safety'
 require 'active_support/core_ext/string/exclude'

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

@@ -20,19 +20,17 @@ class String
     return if parts.empty?
 
     now = Time.now
-    offset = parts[:offset]
-    utc_offset = form == :utc ? 0 : now.utc_offset
-    adjustment = offset ? offset - utc_offset : 0
-
-    Time.send(
-      form,
+    time = Time.new(
       parts.fetch(:year, now.year),
       parts.fetch(:mon, now.month),
       parts.fetch(:mday, now.day),
       parts.fetch(:hour, 0),
       parts.fetch(:min, 0),
-      parts.fetch(:sec, 0) + parts.fetch(:sec_fraction, 0)
-    ) - adjustment
+      parts.fetch(:sec, 0) + parts.fetch(:sec_fraction, 0),
+      parts.fetch(:offset, form == :utc ? 0 : nil)
+    )
+
+    form == :utc ? time.utc : time.getlocal
   end
 
   # Converts a string to a Date value.