activesupport 3.1.12 → 3.2.0.rc1

data/lib/active_support/core_ext/date/freeze.rb

@@ -5,7 +5,7 @@
 # first call will result in a frozen object error since the memo
 # instance variable is uninitialized.
 #
-# Work around by eagerly memoizing before freezing.
+# Work around by eagerly memoizing before the first freeze.
 #
 # Ruby 1.9 uses a preinitialized instance variable so it's unaffected.
 # This hack is as close as we can get to feature detection:
@@ -17,9 +17,11 @@ if RUBY_VERSION < '1.9'
     if frozen_object_error.message =~ /frozen/
       class Date #:nodoc:
         def freeze
-          self.class.private_instance_methods(false).each do |m|
-            if m.to_s =~ /\A__\d+__\Z/
-              instance_variable_set(:"@#{m}", [send(m)])
+          unless frozen?
+            self.class.private_instance_methods(false).each do |m|
+              if m.to_s =~ /\A__\d+__\Z/
+                instance_variable_set(:"@#{m}", [send(m)])
+              end
             end
           end
 

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

@@ -4,7 +4,7 @@ class DateTime
   class << self
     # DateTimes aren't aware of DST rules, so use a consistent non-DST offset when creating a DateTime with an offset in the local zone
     def local_offset
-      ::Time.local(2012).utc_offset.to_r / 86400
+      ::Time.local(2007).utc_offset.to_r / 86400
     end
 
     # Returns <tt>Time.zone.now.to_datetime</tt> when <tt>Time.zone</tt> or <tt>config.time_zone</tt> are set, otherwise returns <tt>Time.now.to_datetime</tt>.

data/lib/active_support/core_ext/enumerable.rb

@@ -20,6 +20,7 @@ module Enumerable
   #   "2006-02-24 -> Transcript, Transcript"
   #   "2006-02-23 -> Transcript"
   def group_by
+    return to_enum :group_by unless block_given?
     assoc = ActiveSupport::OrderedHash.new
 
     each do |element|
@@ -62,6 +63,13 @@ module Enumerable
     end
   end
 
+  # Plucks the value of the passed method for each element and returns the result as an array. Example:
+  #
+  #   people.pluck(:name) # => [ "David Heinemeier Hansson", "Jamie Heinemeier Hansson" ]
+  def pluck(method)
+    collect { |element| element.send(method) }
+  end
+
   # Iterates over a collection, passing the current element *and* the
   # +memo+ to the block. Handy for building up hashes or
   # reducing collections down to one object. Examples:
@@ -75,9 +83,10 @@ module Enumerable
   #
   #   (1..5).each_with_object(1) { |value, memo| memo *= value } # => 1
   #
-  def each_with_object(memo, &block)
+  def each_with_object(memo)
+    return to_enum :each_with_object, memo unless block_given?
     each do |element|
-      block.call(element, memo)
+      yield element, memo
     end
     memo
   end unless [].respond_to?(:each_with_object)
@@ -90,17 +99,25 @@ module Enumerable
   #     => { "Chade- Fowlersburg-e" => <Person ...>, "David Heinemeier Hansson" => <Person ...>, ...}
   #
   def index_by
+    return to_enum :index_by unless block_given?
     Hash[map { |elem| [yield(elem), elem] }]
   end
 
-  # Returns true if the collection has more than 1 element. Functionally equivalent to collection.size > 1.
-  # Can be called with a block too, much like any?, so people.many? { |p| p.age > 26 } returns true if more than 1 person is over 26.
-  def many?(&block)
-    size = block_given? ? count(&block) : self.size
-    size > 1
+  # Returns true if the enumerable has more than 1 element. Functionally equivalent to enum.to_a.size > 1.
+  # Can be called with a block too, much like any?, so <tt>people.many? { |p| p.age > 26 }</tt> returns true if more than one person is over 26.
+  def many?
+    cnt = 0
+    if block_given?
+      any? do |element|
+        cnt += 1 if yield element
+        cnt > 1
+      end
+    else
+      any?{ (cnt += 1) > 1 }
+    end
   end
 
-  # The negative of the Enumerable#include?. Returns true if the collection does not include the object.
+  # The negative of the <tt>Enumerable#include?</tt>. Returns true if the collection does not include the object.
   def exclude?(object)
     !include?(object)
   end

data/lib/active_support/core_ext/file/atomic.rb

@@ -1,5 +1,5 @@
 class File
-  # Write to a file atomically.  Useful for situations where you don't
+  # Write to a file atomically. Useful for situations where you don't
   # want other processes or threads to see half-written files.
   #
   #   File.atomic_write("important.file") do |file|
@@ -17,7 +17,6 @@ class File
     require 'fileutils' unless defined?(FileUtils)
 
     temp_file = Tempfile.new(basename(file_name), temp_dir)
-    temp_file.binmode
     yield temp_file
     temp_file.close
 

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

@@ -85,33 +85,15 @@ class Hash
     end
   end
 
-  class DisallowedType < StandardError #:nodoc:
-    def initialize(type)
-      super "Disallowed type attribute: #{type.inspect}"
-    end
-  end
-
-  DISALLOWED_XML_TYPES = %w(symbol yaml)
-
   class << self
-    def from_xml(xml, disallowed_types = nil)
-      typecast_xml_value(unrename_keys(ActiveSupport::XmlMini.parse(xml)), disallowed_types)
-    end
-
-    def from_trusted_xml(xml)
-      from_xml xml, []
+    def from_xml(xml)
+      typecast_xml_value(unrename_keys(ActiveSupport::XmlMini.parse(xml)))
     end
 
     private
-      def typecast_xml_value(value, disallowed_types = nil)
-        disallowed_types ||= DISALLOWED_XML_TYPES
-
+      def typecast_xml_value(value)
         case value.class.to_s
           when 'Hash'
-            if value.include?('type') && !value['type'].is_a?(Hash) && disallowed_types.include?(value['type'])
-              raise DisallowedType, value['type']
-            end
-
             if value['type'] == 'array'
               _, entries = Array.wrap(value.detect { |k,v| not v.is_a?(String) })
               if entries.nil? || (c = value['__content__'] && c.blank?)
@@ -119,9 +101,9 @@ class Hash
               else
                 case entries.class.to_s   # something weird with classes not matching here.  maybe singleton methods breaking is_a?
                 when "Array"
-                  entries.collect { |v| typecast_xml_value(v, disallowed_types) }
+                  entries.collect { |v| typecast_xml_value(v) }
                 when "Hash"
-                  [typecast_xml_value(entries, disallowed_types)]
+                  [typecast_xml_value(entries)]
                 else
                   raise "can't typecast #{entries.inspect}"
                 end
@@ -145,14 +127,14 @@ class Hash
             elsif value['type'] && value.size == 1 && !value['type'].is_a?(::Hash)
               nil
             else
-              xml_value = Hash[value.map { |k,v| [k, typecast_xml_value(v, disallowed_types)] }]
+              xml_value = Hash[value.map { |k,v| [k, typecast_xml_value(v)] }]
 
               # Turn { :files => { :file => #<StringIO> } into { :files => #<StringIO> } so it is compatible with
               # how multipart uploaded files from HTML appear
               xml_value["file"].is_a?(StringIO) ? xml_value["file"] : xml_value
             end
           when 'Array'
-            value.map! { |i| typecast_xml_value(i, disallowed_types) }
+            value.map! { |i| typecast_xml_value(i) }
             value.length > 1 ? value : value.first
           when 'String'
             value

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

@@ -2,7 +2,7 @@ require 'active_support/hash_with_indifferent_access'
 
 class Hash
 
-  # Returns an +ActiveSupport::HashWithIndifferentAccess+ out of its receiver:
+  # Returns an <tt>ActiveSupport::HashWithIndifferentAccess</tt> out of its receiver:
   #
   #   {:a => 1}.with_indifferent_access["a"] # => 1
   #

data/lib/active_support/core_ext/io.rb

@@ -0,0 +1,15 @@
+if RUBY_VERSION < '1.9.2'
+
+# :stopdoc:
+class IO
+  def self.binread(name, length = nil, offset = nil)
+    return File.read name unless length || offset
+    File.open(name, 'rb') { |f|
+      f.seek offset if offset
+      f.read length
+    }
+  end
+end
+# :startdoc:
+
+end

data/lib/active_support/core_ext/kernel.rb

@@ -1,5 +1,4 @@
 require 'active_support/core_ext/kernel/reporting'
 require 'active_support/core_ext/kernel/agnostics'
-require 'active_support/core_ext/kernel/requires'
 require 'active_support/core_ext/kernel/debugger'
 require 'active_support/core_ext/kernel/singleton_class'

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

@@ -1,11 +1,11 @@
 class Object
   # Makes backticks behave (somewhat more) similarly on all platforms.
   # On win32 `nonexistent_command` raises Errno::ENOENT; on Unix, the
-  # spawned shell prints a message to stderr and sets $?.  We emulate
+  # spawned shell prints a message to stderr and sets $?. We emulate
   # Unix on the former but not the latter.
   def `(command) #:nodoc:
     super
   rescue Errno::ENOENT => e
     STDERR.puts "#$0: #{e}"
   end
-end
+end

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

@@ -5,12 +5,6 @@ module Kernel
       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"
       defined?(Rails) ? Rails.logger.info(message) : $stderr.puts(message)
     end
-  end
-
-  undef :breakpoint if respond_to?(:breakpoint)
-  def breakpoint
-    message = "\n***** The 'breakpoint' command has been renamed 'debugger' -- please change *****\n"
-    defined?(Rails) ? Rails.logger.info(message) : $stderr.puts(message)
-    debugger
+    alias breakpoint debugger unless respond_to?(:breakpoint)
   end
 end

data/lib/active_support/core_ext/module.rb

@@ -4,9 +4,9 @@ require 'active_support/core_ext/module/anonymous'
 require 'active_support/core_ext/module/reachable'
 require 'active_support/core_ext/module/attribute_accessors'
 require 'active_support/core_ext/module/attr_internal'
-require 'active_support/core_ext/module/attr_accessor_with_default'
 require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/module/synchronization'
 require 'active_support/core_ext/module/deprecation'
 require 'active_support/core_ext/module/remove_method'
-require 'active_support/core_ext/module/method_names'
+require 'active_support/core_ext/module/method_names'
+require 'active_support/core_ext/module/qualified_const'

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

@@ -12,7 +12,7 @@ class Module
         end
       EOS
 
-      unless options[:instance_reader] == false
+      unless options[:instance_reader] == false || options[:instance_accessor] == false
         class_eval(<<-EOS, __FILE__, __LINE__ + 1)
           def #{sym}
             @@#{sym}
@@ -31,7 +31,7 @@ class Module
         end
       EOS
 
-      unless options[:instance_writer] == false
+      unless options[:instance_writer] == false || options[:instance_accessor] == false
         class_eval(<<-EOS, __FILE__, __LINE__ + 1)
           def #{sym}=(obj)
             @@#{sym} = obj
@@ -53,6 +53,10 @@ class Module
   #  end
   #
   #  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.
   def mattr_accessor(*syms)
     mattr_reader(*syms)
     mattr_writer(*syms)

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

@@ -1,5 +1,3 @@
-require "active_support/core_ext/module/remove_method"
-
 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)
@@ -108,35 +106,48 @@ class Module
     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)."
     end
+    prefix, to, allow_nil = options[:prefix], options[:to], options[:allow_nil]
 
-    if options[:prefix] == true && options[:to].to_s =~ /^[^a-z_]/
+    if prefix == true && to.to_s =~ /^[^a-z_]/
       raise ArgumentError, "Can only automatically set the delegation prefix when delegating to a method."
     end
 
-    prefix = options[:prefix] && "#{options[:prefix] == true ? to : options[:prefix]}_" || ''
+    method_prefix =
+      if prefix
+        "#{prefix == true ? to : prefix}_"
+      else
+        ''
+      end
 
     file, line = caller.first.split(':', 2)
     line = line.to_i
 
     methods.each do |method|
-      on_nil =
-        if options[:allow_nil]
-          'return'
-        else
-          %(raise "#{self}##{prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
-        end
+      method = method.to_s
+
+      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)
+            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 #{prefix}#{method}(*args, &block)               # def customer_name(*args, &block)
-          #{to}.__send__(#{method.inspect}, *args, &block)  #   client.__send__(:name, *args, &block)
-        rescue NoMethodError                                # rescue NoMethodError
-          if #{to}.nil?                                     #   if client.nil?
-            #{on_nil}                                       #     return # depends on :allow_nil
-          else                                              #   else
-            raise                                           #     raise
-          end                                               #   end
-        end                                                 # end
-      EOS
+        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)
+          rescue NoMethodError                                # rescue NoMethodError
+            if #{to}.nil?                                     #   if client.nil?
+              #{exception}                                    #     # add helpful message to the exception
+            else                                              #   else
+              raise                                           #     raise
+            end                                               #   end
+          end                                                 # end
+        EOS
+      end
     end
   end
 end

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

@@ -0,0 +1,64 @@
+require 'active_support/core_ext/string/inflections'
+
+#--
+# Allows code reuse in the methods below without polluting Module.
+#++
+module QualifiedConstUtils
+  def self.raise_if_absolute(path)
+    raise NameError, "wrong constant name #$&" if path =~ /\A::[^:]+/
+  end
+
+  def self.names(path)
+    path.split('::')
+  end
+end
+
+##
+# Extends the API for constants to be able to deal with qualified names. Arguments
+# are assumed to be relative to the receiver.
+#
+#--
+# Qualified names are required to be relative because we are extending existing
+# methods that expect constant names, ie, relative paths of length 1. For example,
+# Object.const_get("::String") raises NameError and so does qualified_const_get.
+#++
+class Module
+  if method(:const_defined?).arity == 1
+    def qualified_const_defined?(path)
+      QualifiedConstUtils.raise_if_absolute(path)
+
+      QualifiedConstUtils.names(path).inject(self) do |mod, name|
+        return unless mod.const_defined?(name)
+        mod.const_get(name)
+      end
+      return true
+    end
+  else
+    def qualified_const_defined?(path, search_parents=true)
+      QualifiedConstUtils.raise_if_absolute(path)
+
+      QualifiedConstUtils.names(path).inject(self) do |mod, name|
+        return unless mod.const_defined?(name, search_parents)
+        mod.const_get(name)
+      end
+      return true
+    end
+  end
+
+  def qualified_const_get(path)
+    QualifiedConstUtils.raise_if_absolute(path)
+
+    QualifiedConstUtils.names(path).inject(self) do |mod, name|
+      mod.const_get(name)
+    end
+  end
+
+  def qualified_const_set(path, value)
+    QualifiedConstUtils.raise_if_absolute(path)
+
+    const_name = path.demodulize
+    mod_name = path.deconstantize
+    mod = mod_name.empty? ? self : qualified_const_get(mod_name)
+    mod.const_set(const_name, value)
+  end
+end

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

@@ -3,8 +3,6 @@ require 'active_support/core_ext/string/inflections'
 
 class Module
   def reachable? #:nodoc:
-    !anonymous? && name.constantize.equal?(self)
-  rescue NameError
-    false
+    !anonymous? && name.safe_constantize.equal?(self)
   end
 end

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

@@ -1,6 +1,7 @@
 require 'thread'
 require 'active_support/core_ext/module/aliasing'
 require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/module/deprecation'
 
 class Module
   # Synchronize access around a method, delegating synchronization to a
@@ -40,4 +41,5 @@ class Module
       alias_method_chain method, :synchronization
     end
   end
+  deprecate :synchronize
 end