activesupport 3.1.12 → 3.2.0.rc1

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

@@ -1,3 +1,6 @@
+# encoding: utf-8
+require 'active_support/core_ext/string/encoding'
+
 class Object
   # An object is blank if it's false, empty, or a whitespace string.
   # For example, "", "   ", +nil+, [], and {} are all blank.
@@ -22,7 +25,7 @@ class Object
   # <tt>object.presence</tt> is equivalent to <tt>object.present? ? object : nil</tt>.
   #
   # This is handy for any representation of objects where blank is the same
-  # as not present at all.  For example, this simplifies a common check for
+  # as not present at all. For example, this simplifies a common check for
   # HTTP POST/query parameters:
   #
   #   state   = params[:state]   if params[:state].present?
@@ -86,14 +89,23 @@ class Hash
 end
 
 class String
+  # 0x3000: fullwidth whitespace
+  NON_WHITESPACE_REGEXP = %r![^\s#{[0x3000].pack("U")}]!
+
   # A string is blank if it's empty or contains whitespaces only:
   #
   #   "".blank?                 # => true
   #   "   ".blank?              # => true
+  #   "　".blank?               # => true
   #   " something here ".blank? # => false
   #
   def blank?
-    self !~ /\S/
+    # 1.8 does not takes [:space:] properly
+    if encoding_aware?
+      self !~ /[^[:space:]]/
+    else
+      self !~ NON_WHITESPACE_REGEXP
+    end
   end
 end
 

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

@@ -1,15 +1,25 @@
 class Object
-  # Returns true if this object is included in the argument. Argument must be
-  # any object which responds to +#include?+. Usage:
+  # Returns true if this object is included in the argument(s). Argument must be
+  # any object which responds to +#include?+ or optionally, multiple arguments can be passed in. Usage:
   #
   #   characters = ["Konata", "Kagami", "Tsukasa"]
   #   "Konata".in?(characters) # => true
+  #   
+  #   character = "Konata"
+  #   character.in?("Konata", "Kagami", "Tsukasa") # => true
   #
-  # This will throw an ArgumentError if the argument doesn't respond
+  # This will throw an ArgumentError if a single argument is passed in and it doesn't respond
   # to +#include?+.
-  def in?(another_object)
-    another_object.include?(self)
-  rescue NoMethodError
-    raise ArgumentError.new("The parameter passed to #in? must respond to #include?")
+  def in?(*args)
+    if args.length > 1
+      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
   end
 end

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

@@ -10,10 +10,10 @@ end
 # 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 <<-RUBY, __FILE__, __LINE__
+  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
-  RUBY
+  end
 end

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

@@ -7,7 +7,7 @@ class Range
   #
   # ==== Example
   #
-  #   [1..100].to_formatted_s # => "1..100"
+  #   (1..100).to_formatted_s # => "1..100"
   def to_formatted_s(format = :default)
     if formatter = RANGE_FORMATS[format]
       formatter.call(first, last)

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

@@ -35,9 +35,9 @@ class String
   # Form can be either :utc (default) or :local.
   def to_time(form = :utc)
     return nil if self.blank?
-    d = ::Date._parse(self, false).values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction).map { |arg| arg || 0 }
+    d = ::Date._parse(self, false).values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction, :offset).map { |arg| arg || 0 }
     d[6] *= 1000000
-    ::Time.send("#{form}_time", *d)
+    ::Time.send("#{form}_time", *d[0..6]) - d[7]
   end
 
   def to_date

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

@@ -1,5 +1,4 @@
 require 'active_support/inflector/methods'
-require 'active_support/inflector/inflections'
 require 'active_support/inflector/transliterate'
 
 # String inflections define new methods on the String class to transform names for different purposes.
@@ -10,14 +9,25 @@ require 'active_support/inflector/transliterate'
 class String
   # Returns the plural form of the word in the string.
   #
+  # If the optional parameter +count+ is specified,
+  # the singular form will be returned if <tt>count == 1</tt>.
+  # For any other value of +count+ the plural will be returned.
+  #
+  # ==== Examples
   #   "post".pluralize             # => "posts"
   #   "octopus".pluralize          # => "octopi"
   #   "sheep".pluralize            # => "sheep"
   #   "words".pluralize            # => "words"
   #   "the blue mailman".pluralize # => "the blue mailmen"
   #   "CamelOctopus".pluralize     # => "CamelOctopi"
-  def pluralize
-    ActiveSupport::Inflector.pluralize(self)
+  #   "apple".pluralize(1)         # => "apple"
+  #   "apple".pluralize(2)         # => "apples"
+  def pluralize(count = nil)
+    if count == 1
+      self
+    else
+      ActiveSupport::Inflector.pluralize(self)
+    end
   end
 
   # The reverse of +pluralize+, returns the singular form of a word in a string.
@@ -34,15 +44,28 @@ class String
 
   # +constantize+ tries to find a declared constant with the name specified
   # in the string. It raises a NameError when the name is not in CamelCase
-  # or is not initialized.
+  # or is not initialized.  See ActiveSupport::Inflector.constantize
   #
   # Examples
-  #   "Module".constantize # => Module
-  #   "Class".constantize  # => Class
+  #   "Module".constantize  # => Module
+  #   "Class".constantize   # => Class
+  #   "blargle".constantize # => NameError: wrong constant name blargle
   def constantize
     ActiveSupport::Inflector.constantize(self)
   end
 
+  # +safe_constantize+ tries to find a declared constant with the name specified
+  # in the string. It returns nil when the name is not in CamelCase
+  # or is not initialized.  See ActiveSupport::Inflector.safe_constantize
+  #
+  # Examples
+  #   "Module".safe_constantize  # => Module
+  #   "Class".safe_constantize   # => Class
+  #   "blargle".safe_constantize # => nil
+  def safe_constantize
+    ActiveSupport::Inflector.safe_constantize(self)
+  end
+
   # By default, +camelize+ converts strings to UpperCamelCase. If the argument to camelize
   # is set to <tt>:lower</tt> then camelize produces lowerCamelCase.
   #
@@ -94,10 +117,25 @@ class String
   #
   #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections"
   #   "Inflections".demodulize                                       # => "Inflections"
+  #
+  # See also +deconstantize+.
   def demodulize
     ActiveSupport::Inflector.demodulize(self)
   end
 
+  # Removes the rightmost segment from the constant expression in the string.
+  #
+  #   "Net::HTTP".deconstantize   # => "Net"
+  #   "::Net::HTTP".deconstantize # => "::Net"
+  #   "String".deconstantize      # => ""
+  #   "::String".deconstantize    # => ""
+  #   "".deconstantize            # => ""
+  #
+  # See also +demodulize+.
+  def deconstantize
+    ActiveSupport::Inflector.deconstantize(self)
+  end
+
   # Replaces special characters in a string so that it may be used as part of a 'pretty' URL.
   #
   # ==== Examples

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

@@ -44,7 +44,7 @@ class String
       end
     end
 
-    def is_utf8? #:nodoc
+    def is_utf8?
       case encoding
       when Encoding::UTF_8
         valid_encoding?

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

@@ -3,10 +3,11 @@ require 'active_support/core_ext/kernel/singleton_class'
 
 class ERB
   module Util
-    HTML_ESCAPE = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;', "'" => '&#x27;' }
+    HTML_ESCAPE = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;' }
     JSON_ESCAPE = { '&' => '\u0026', '>' => '\u003E', '<' => '\u003C' }
 
-    if RUBY_VERSION >= '1.9'
+    # Detect whether 1.9 can transcode with XML escaping.
+    if '"&gt;&lt;&amp;&quot;"' == ('><&"'.encode('utf-8', :xml => :attr) rescue false)
       # A utility method for escaping HTML tag characters.
       # This method is also aliased as <tt>h</tt>.
       #
@@ -21,7 +22,7 @@ class ERB
         if s.html_safe?
           s
         else
-          s.gsub(/[&"'><]/, HTML_ESCAPE).html_safe
+          s.encode(s.encoding, :xml => :attr)[1...-1].html_safe
         end
       end
     else
@@ -30,7 +31,7 @@ class ERB
         if s.html_safe?
           s
         else
-          s.gsub(/[&"'><]/n) { |special| HTML_ESCAPE[special] }.html_safe
+          s.gsub(/[&"><]/n) { |special| HTML_ESCAPE[special] }.html_safe
         end
       end
     end
@@ -97,39 +98,29 @@ module ActiveSupport #:nodoc:
       end
     end
 
-    def [](*args)
-      return super if args.size < 2
-
-      if html_safe?
-        new_safe_buffer = super
-        new_safe_buffer.instance_eval { @html_safe = true }
-        new_safe_buffer
-      else
-        to_str[*args]
-      end
+    def[](*args)
+      new_safe_buffer = super
+      new_safe_buffer.instance_eval { @dirty = false }
+      new_safe_buffer
     end
 
     def safe_concat(value)
-      raise SafeConcatError unless html_safe?
+      raise SafeConcatError if dirty?
       original_concat(value)
     end
 
     def initialize(*)
-      @html_safe = true
+      @dirty = false
       super
     end
 
     def initialize_copy(other)
       super
-      @html_safe = other.html_safe?
-    end
-
-    def clone_empty
-      self[0, 0]
+      @dirty = other.dirty?
     end
 
     def concat(value)
-      if !html_safe? || value.html_safe?
+      if dirty? || value.html_safe?
         super(value)
       else
         super(ERB::Util.h(value))
@@ -142,7 +133,7 @@ module ActiveSupport #:nodoc:
     end
 
     def html_safe?
-      defined?(@html_safe) && @html_safe
+      !dirty?
     end
 
     def to_s
@@ -162,7 +153,7 @@ module ActiveSupport #:nodoc:
       to_str.to_yaml(*args)
     end
 
-    for unsafe_method in UNSAFE_STRING_METHODS
+    UNSAFE_STRING_METHODS.each do |unsafe_method|
       if 'String'.respond_to?(unsafe_method)
         class_eval <<-EOT, __FILE__, __LINE__ + 1
           def #{unsafe_method}(*args, &block)       # def capitalize(*args, &block)
@@ -170,12 +161,18 @@ module ActiveSupport #:nodoc:
           end                                       # end
 
           def #{unsafe_method}!(*args)              # def capitalize!(*args)
-            @html_safe = false                      #   @html_safe = false
+            @dirty = true                           #   @dirty = true
             super                                   #   super
           end                                       # end
         EOT
       end
     end
+
+    protected
+
+    def dirty?
+      @dirty
+    end
   end
 end
 

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

@@ -161,27 +161,46 @@ class Time
     months_since(1)
   end
 
-  # Returns a new Time representing the "start" of this week (Monday, 0:00)
-  def beginning_of_week
-    days_to_monday = wday!=0 ? wday-1 : 6
-    (self - days_to_monday.days).midnight
+  # Returns number of days to start of this week, week starts on start_day (default is :monday).
+  def days_to_week_start(start_day = :monday)
+    start_day_number = DAYS_INTO_WEEK[start_day]
+    current_day_number = wday != 0 ? wday - 1 : 6
+    days_span = current_day_number - start_day_number
+    days_span >= 0 ? days_span : 7 + days_span
+  end
+
+  # Returns a new Time representing the "start" of this week, week starts on start_day (default is :monday, i.e. Monday, 0:00).
+  def beginning_of_week(start_day = :monday)
+    days_to_start = days_to_week_start(start_day)
+    (self - days_to_start.days).midnight
   end
-  alias :monday :beginning_of_week
   alias :at_beginning_of_week :beginning_of_week
 
-  # Returns a new Time representing the end of this week, (end of Sunday)
-  def end_of_week
-    days_to_sunday = wday!=0 ? 7-wday : 0
-    (self + days_to_sunday.days).end_of_day
+  # Returns a new +Date+/+DateTime+ representing the start of this week. Week is
+  # assumed to start on a Monday. +DateTime+ objects have their time set to 0:00.
+  def monday
+    beginning_of_week
+  end
+
+  # Returns a new Time representing the end of this week, week starts on start_day (default is :monday, i.e. end of Sunday).
+  def end_of_week(start_day = :monday)
+    days_to_end =  6 - days_to_week_start(start_day)
+    (self + days_to_end.days).end_of_day
   end
   alias :at_end_of_week :end_of_week
 
-  # Returns a new Time representing the start of the given day in the previous week (default is Monday).
+  # Returns a new +Date+/+DateTime+ representing the end of this week. Week is
+  # assumed to start on a Monday. +DateTime+ objects have their time set to 23:59:59.
+  def sunday
+    end_of_week
+  end
+
+  # Returns a new Time representing the start of the given day in the previous week (default is :monday).
   def prev_week(day = :monday)
     ago(1.week).beginning_of_week.since(DAYS_INTO_WEEK[day].day).change(:hour => 0)
   end
 
-  # Returns a new Time representing the start of the given day in next week (default is Monday).
+  # Returns a new Time representing the start of the given day in next week (default is :monday).
   def next_week(day = :monday)
     since(1.week).beginning_of_week.since(DAYS_INTO_WEEK[day].day).change(:hour => 0)
   end
@@ -227,7 +246,7 @@ class Time
   end
   alias :at_end_of_quarter :end_of_quarter
 
-  # Returns  a new Time representing the start of the year (1st of january, 0:00)
+  # Returns a new Time representing the start of the year (1st of january, 0:00)
   def beginning_of_year
     change(:month => 1, :day => 1, :hour => 0)
   end
@@ -249,6 +268,31 @@ class Time
     advance(:days => 1)
   end
 
+  # Returns a Range representing the whole day of the current time.
+  def all_day
+    beginning_of_day..end_of_day
+  end
+
+  # Returns a Range representing the whole week of the current time.
+  def all_week
+    beginning_of_week..end_of_week
+  end
+
+  # Returns a Range representing the whole month of the current time.
+  def all_month
+    beginning_of_month..end_of_month
+  end
+
+  # Returns a Range representing the whole quarter of the current time.
+  def all_quarter
+    beginning_of_quarter..end_of_quarter
+  end
+
+  # Returns a Range representing the whole year of the current time.
+  def all_year
+    beginning_of_year..end_of_year
+  end
+
   def plus_with_duration(other) #:nodoc:
     if ActiveSupport::Duration === other
       other.since(self)
@@ -287,4 +331,14 @@ class Time
   end
   alias_method :compare_without_coercion, :<=>
   alias_method :<=>, :compare_with_coercion
+
+  # Layers additional behavior on Time#eql? so that ActiveSupport::TimeWithZone instances
+  # can be eql? to an equivalent Time
+  def eql_with_coercion(other)
+    # if other is an ActiveSupport::TimeWithZone, coerce a Time instance from it so we can do eql? comparison
+    other = other.comparable_time if other.respond_to?(:comparable_time)
+    eql_without_coercion(other)
+  end
+  alias_method :eql_without_coercion, :eql?
+  alias_method :eql?, :eql_with_coercion
 end

data/lib/active_support/dependencies.rb

@@ -5,7 +5,7 @@ require 'active_support/core_ext/module/aliasing'
 require 'active_support/core_ext/module/attribute_accessors'
 require 'active_support/core_ext/module/introspection'
 require 'active_support/core_ext/module/anonymous'
-require 'active_support/core_ext/module/deprecation'
+require 'active_support/core_ext/module/qualified_const'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/load_error'
 require 'active_support/core_ext/name_error'
@@ -71,14 +71,24 @@ module ActiveSupport #:nodoc:
     #
     # This is handled by walking back up the watch stack and adding the constants
     # found by child.rb to the list of original constants in parent.rb
-    class WatchStack < Hash
+    class WatchStack
+      include Enumerable
+
       # @watching is a stack of lists of constants being watched. For instance,
       # if parent.rb is autoloaded, the stack will look like [[Object]]. If parent.rb
       # then requires namespace/child.rb, the stack will look like [[Object], [Namespace]].
 
       def initialize
         @watching = []
-        super { |h,k| h[k] = [] }
+        @stack = Hash.new { |h,k| h[k] = [] }
+      end
+
+      def each(&block)
+        @stack.each(&block)
+      end
+
+      def watching?
+        !@watching.empty?
       end
 
       # return a list of new constants found since the last call to watch_namespaces
@@ -89,7 +99,7 @@ module ActiveSupport #:nodoc:
         @watching.last.each do |namespace|
           # Retrieve the constants that were present under the namespace when watch_namespaces
           # was originally called
-          original_constants = self[namespace].last
+          original_constants = @stack[namespace].last
 
           mod = Inflector.constantize(namespace) if Dependencies.qualified_const_defined?(namespace)
           next unless mod.is_a?(Module)
@@ -102,7 +112,7 @@ module ActiveSupport #:nodoc:
           # element of self[Object] will be an Array of the constants that were present
           # before parent.rb was required. The second element will be an Array of the
           # constants that were present before child.rb was required.
-          self[namespace].each do |namespace_constants|
+          @stack[namespace].each do |namespace_constants|
             namespace_constants.concat(new_constants)
           end
 
@@ -126,13 +136,14 @@ module ActiveSupport #:nodoc:
             Inflector.constantize(module_name).local_constant_names : []
 
           watching << module_name
-          self[module_name] << original_constants
+          @stack[module_name] << original_constants
         end
         @watching << watching
       end
 
+      private
       def pop_modules(modules)
-        modules.each { |mod| self[mod].pop }
+        modules.each { |mod| @stack[mod].pop }
       end
     end
 
@@ -219,8 +230,8 @@ module ActiveSupport #:nodoc:
       end
 
       def load_dependency(file)
-        if Dependencies.load?
-          Dependencies.new_constants_in(Object) { yield }.presence
+        if Dependencies.load? && ActiveSupport::Dependencies.constant_watch_stack.watching?
+          Dependencies.new_constants_in(Object) { yield }
         else
           yield
         end
@@ -229,13 +240,13 @@ module ActiveSupport #:nodoc:
         raise
       end
 
-      def load(file, *)
+      def load(file, wrap = false)
         result = false
         load_dependency(file) { result = super }
         result
       end
 
-      def require(file, *)
+      def require(file)
         result = false
         load_dependency(file) { result = super }
         result
@@ -358,12 +369,13 @@ module ActiveSupport #:nodoc:
     end
 
     # Is the provided constant path defined?
-    def qualified_const_defined?(path)
-      names = path.sub(/^::/, '').to_s.split('::')
-
-      names.inject(Object) do |mod, name|
-        return false unless local_const_defined?(mod, name)
-        mod.const_get name
+    if Module.method(:const_defined?).arity == 1
+      def qualified_const_defined?(path)
+        Object.qualified_const_defined?(path.sub(/^::/, ''))
+      end
+    else
+      def qualified_const_defined?(path)
+        Object.qualified_const_defined?(path.sub(/^::/, ''), false)
       end
     end
 
@@ -422,7 +434,8 @@ module ActiveSupport #:nodoc:
     end
 
     def load_once_path?(path)
-      autoload_once_paths.any? { |base| path.starts_with? base }
+      # to_s works around a ruby1.9 issue where #starts_with?(Pathname) will always return false
+      autoload_once_paths.any? { |base| path.starts_with? base.to_s }
     end
 
     # Attempt to autoload the provided module name by searching for a directory
@@ -525,7 +538,7 @@ module ActiveSupport #:nodoc:
 
     class ClassCache
       def initialize
-        @store = Hash.new { |h, k| h[k] = Inflector.constantize(k) }
+        @store = Hash.new
       end
 
       def empty?
@@ -536,40 +549,24 @@ module ActiveSupport #:nodoc:
         @store.key?(key)
       end
 
-      def []=(key, value)
-        return unless key.respond_to?(:name)
-
-        raise(ArgumentError, 'anonymous classes cannot be cached') if key.name.blank?
-
-        @store[key.name] = value
-      end
-
-      def [](key)
+      def get(key)
         key = key.name if key.respond_to?(:name)
-
-        @store[key]
+        @store[key] ||= Inflector.constantize(key)
       end
-      alias :get :[]
-
-      class Getter # :nodoc:
-        def initialize(name)
-          @name = name
-        end
+      alias :[] :get
 
-        def get
-          Reference.get @name
+      def safe_get(key)
+        key = key.name if key.respond_to?(:name)
+        @store[key] || begin
+          klass = Inflector.safe_constantize(key)
+          @store[key] = klass
         end
-        deprecate :get
       end
 
-      def new(name)
-        self[name] = name
-        Getter.new(name)
-      end
-      deprecate :new
-
-      def store(name)
-        self[name] = name
+      def store(klass)
+        return self unless klass.respond_to?(:name)
+        raise(ArgumentError, 'anonymous classes cannot be cached') if klass.name.empty?
+        @store[klass.name] = klass
         self
       end
 
@@ -580,21 +577,23 @@ module ActiveSupport #:nodoc:
 
     Reference = ClassCache.new
 
-    def ref(name)
-      Reference.new(name)
-    end
-    deprecate :ref
-
     # Store a reference to a class +klass+.
     def reference(klass)
       Reference.store klass
     end
 
     # Get the reference for class named +name+.
+    # Raises an exception if referenced class does not exist.
     def constantize(name)
       Reference.get(name)
     end
 
+    # Get the reference for class named +name+ if one exists.
+    # Otherwise returns nil.
+    def safe_constantize(name)
+      Reference.safe_get(name)
+    end
+
     # Determine if the given constant has been automatically loaded.
     def autoloaded?(desc)
       # No name => anonymous module.