activesupport 3.0.20 → 3.1.0.beta1

data/lib/active_support/core_ext/uri.rb

@@ -20,3 +20,11 @@ if RUBY_VERSION >= '1.9'
     end
   end
 end
+
+module URI
+  class << self
+    def parser
+      @parser ||= URI.const_defined?(:Parser) ? URI::Parser.new : URI
+    end
+  end
+end

data/lib/active_support/dependencies.rb

@@ -5,6 +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/object/blank'
 require 'active_support/core_ext/load_error'
 require 'active_support/core_ext/name_error'
@@ -47,9 +48,6 @@ module ActiveSupport #:nodoc:
     mattr_accessor :autoloaded_constants
     self.autoloaded_constants = []
 
-    mattr_accessor :references
-    self.references = {}
-
     # An array of constant names that need to be unloaded on every request. Used
     # to allow arbitrary constants to be marked for unloading.
     mattr_accessor :explicitly_unloadable_constants
@@ -64,8 +62,8 @@ module ActiveSupport #:nodoc:
     self.log_activity = false
 
     # The WatchStack keeps a stack of the modules being watched as files are loaded.
-    # If a file in the process of being loaded (parent.rb) triggers the load of 
-    # another file (child.rb) the stack will ensure that child.rb handles the new 
+    # If a file in the process of being loaded (parent.rb) triggers the load of
+    # another file (child.rb) the stack will ensure that child.rb handles the new
     # constants.
     #
     # If child.rb is being autoloaded, its constants will be added to
@@ -83,13 +81,13 @@ module ActiveSupport #:nodoc:
         super { |h,k| h[k] = [] }
       end
 
-      # return a list of new constants found since the last call to watch_modules
+      # return a list of new constants found since the last call to watch_namespaces
       def new_constants
         constants = []
 
         # Grab the list of namespaces that we're looking for new constants under
         @watching.last.each do |namespace|
-          # Retrieve the constants that were present under the namespace when watch_modules
+          # Retrieve the constants that were present under the namespace when watch_namespaces
           # was originally called
           original_constants = self[namespace].last
 
@@ -115,7 +113,7 @@ module ActiveSupport #:nodoc:
         end
         constants
       ensure
-        # A call to new_constants is always called after a call to watch_modules
+        # A call to new_constants is always called after a call to watch_namespaces
         pop_modules(@watching.pop)
       end
 
@@ -166,7 +164,7 @@ module ActiveSupport #:nodoc:
       def const_missing(const_name, nesting = nil)
         klass_name = name.presence || "Object"
 
-        if !nesting
+        unless nesting
           # We'll assume that the nesting of Foo::Bar is ["Foo::Bar", "Foo"]
           # even though it might not be, such as in the case of
           # class Foo::Bar; Baz; end
@@ -232,15 +230,11 @@ module ActiveSupport #:nodoc:
       end
 
       def load(file, *)
-        result = false
-        load_dependency(file) { result = super }
-        result
+        load_dependency(file) { super }
       end
 
       def require(file, *)
-        result = false
-        load_dependency(file) { result = super }
-        result
+        load_dependency(file) { super }
       end
 
       # Mark the given constant as unloadable. Unloadable constants are removed each
@@ -485,6 +479,10 @@ module ActiveSupport #:nodoc:
       qualified_name = qualified_name_for from_mod, const_name
       path_suffix = qualified_name.underscore
 
+      trace = caller.reject {|l| l =~ %r{#{Regexp.escape(__FILE__)}}}
+      name_error = NameError.new("uninitialized constant #{qualified_name}")
+      name_error.set_backtrace(trace)
+
       file_path = search_for_file(path_suffix)
 
       if file_path && ! loaded.include?(File.expand_path(file_path)) # We found a matching file to load
@@ -503,12 +501,11 @@ module ActiveSupport #:nodoc:
           return parent.const_missing(const_name)
         rescue NameError => e
           raise unless e.missing_name? qualified_name_for(parent, const_name)
+          raise name_error
         end
+      else
+        raise name_error
       end
-
-      raise NameError,
-            "uninitialized constant #{qualified_name}",
-            caller.reject {|l| l.starts_with? __FILE__ }
     end
 
     # Remove the constants that have been autoloaded, and those that have been
@@ -516,7 +513,7 @@ module ActiveSupport #:nodoc:
     # to its class/module if it implements +before_remove_const+.
     #
     # The callback implementation should be restricted to cleaning up caches, etc.
-    # as the enviroment will be in an inconsistent state, e.g. other constants
+    # as the environment will be in an inconsistent state, e.g. other constants
     # may have already been unloaded and not accessible.
     def remove_unloadable_constants!
       autoloaded_constants.each { |const| remove_constant const }
@@ -525,31 +522,76 @@ module ActiveSupport #:nodoc:
       explicitly_unloadable_constants.each { |const| remove_constant const }
     end
 
-    class Reference
-      @@constants = Hash.new { |h, k| h[k] = Inflector.constantize(k) }
+    class ClassCache
+      def initialize
+        @store = Hash.new { |h, k| h[k] = Inflector.constantize(k) }
+      end
+
+      def empty?
+        @store.empty?
+      end
+
+      def key?(key)
+        @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)
+        key = key.name if key.respond_to?(:name)
+
+        @store[key]
+      end
+      alias :get :[]
+
+      class Getter # :nodoc:
+        def initialize(name)
+          @name = name
+        end
 
-      attr_reader :name
+        def get
+          Reference.get @name
+        end
+        deprecate :get
+      end
 
-      def initialize(name)
-        @name = name.to_s
-        @@constants[@name] = name if name.respond_to?(:name)
+      def new(name)
+        self[name] = name
+        Getter.new(name)
       end
+      deprecate :new
 
-      def get
-        @@constants[@name]
+      def store(name)
+        self[name] = name
+        self
       end
 
-      def self.clear!
-        @@constants.clear
+      def clear!
+        @store.clear
       end
     end
 
+    Reference = ClassCache.new
+
     def ref(name)
-      references[name] ||= Reference.new(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+.
     def constantize(name)
-      ref(name).get
+      Reference.get(name)
     end
 
     # Determine if the given constant has been automatically loaded.
@@ -609,6 +651,17 @@ module ActiveSupport #:nodoc:
       return []
     end
 
+    class LoadingModule #:nodoc:
+      # Old style environment.rb referenced this method directly.  Please note, it doesn't
+      # actually *do* anything any more.
+      def self.root(*args)
+        if defined?(Rails) && Rails.logger
+          Rails.logger.warn "Your environment.rb uses the old syntax, it may not continue to work in future releases."
+          Rails.logger.warn "For upgrade instructions please see: http://manuals.rubyonrails.com/read/book/19"
+        end
+      end
+    end
+
     # Convert the provided const desc to a qualified constant name (as a string).
     # A module, class, symbol, or string may be provided.
     def to_constant_name(desc) #:nodoc:
@@ -631,7 +684,8 @@ module ActiveSupport #:nodoc:
       parent = Inflector.constantize(names * '::')
 
       log "removing constant #{const}"
-      constantize(const).before_remove_const if constantize(const).respond_to?(:before_remove_const)
+      constantized = constantize(const)
+      constantized.before_remove_const if constantized.respond_to?(:before_remove_const)
       parent.instance_eval { remove_const to_remove }
 
       return true
@@ -639,7 +693,7 @@ module ActiveSupport #:nodoc:
 
     protected
       def log_call(*args)
-        if logger && log_activity
+        if log_activity?
           arg_str = args.collect { |arg| arg.inspect } * ', '
           /in `([a-z_\?\!]+)'/ =~ caller(1).first
           selector = $1 || '<unknown>'
@@ -648,9 +702,11 @@ module ActiveSupport #:nodoc:
       end
 
       def log(msg)
-        if logger && log_activity
-          logger.debug "Dependencies: #{msg}"
-        end
+        logger.debug "Dependencies: #{msg}" if log_activity?
+      end
+
+      def log_activity?
+        logger && log_activity
       end
   end
 end

data/lib/active_support/deprecation.rb

@@ -4,12 +4,12 @@ require 'active_support/deprecation/method_wrappers'
 require 'active_support/deprecation/proxy_wrappers'
 
 module ActiveSupport
-  module Deprecation #:nodoc:
+  module Deprecation
     class << self
       # The version the deprecated behavior will be removed, by default.
       attr_accessor :deprecation_horizon
     end
-    self.deprecation_horizon = '3.0'
+    self.deprecation_horizon = '3.2'
 
     # By default, warnings are not silenced and debugging is off.
     self.silenced = false

data/lib/active_support/deprecation/behaviors.rb

@@ -7,10 +7,17 @@ module ActiveSupport
       # Whether to print a backtrace along with the warning.
       attr_accessor :debug
 
+      # Returns the set behaviour or if one isn't set, defaults to +:stderr+
       def behavior
         @behavior ||= [DEFAULT_BEHAVIORS[:stderr]]
       end
 
+      # Sets the behaviour to the specified value. Can be a single value or an array.
+      #
+      # Examples
+      #
+      #   ActiveSupport::Deprecation.behavior = :stderr
+      #   ActiveSupport::Deprecation.behavior = [:stderr, :log]
       def behavior=(behavior)
         @behavior = Array.wrap(behavior).map { |b| DEFAULT_BEHAVIORS[b] || b }
       end

data/lib/active_support/deprecation/proxy_wrappers.rb

@@ -58,7 +58,7 @@ module ActiveSupport
         end
     end
 
-    class DeprecatedConstantProxy < DeprecationProxy #:nodoc:
+    class DeprecatedConstantProxy < DeprecationProxy #:nodoc:all
       def initialize(old_const, new_const)
         @old_const = old_const
         @new_const = new_const

data/lib/active_support/deprecation/reporting.rb

@@ -3,6 +3,10 @@ module ActiveSupport
     class << self
       attr_accessor :silenced
 
+      # Outputs a deprecation warning to the output configured by <tt>ActiveSupport::Deprecation.behavior</tt>
+      #
+      #   ActiveSupport::Deprecation.warn("something broke!")
+      #   # => "DEPRECATION WARNING: something broke! (called from your_code.rb:1)"
       def warn(message = nil, callstack = caller)
         return if silenced
         deprecation_message(callstack, message).tap do |m|

data/lib/active_support/duration.rb

@@ -80,6 +80,10 @@ module ActiveSupport
       parts.to_sentence(:locale => :en)
     end
 
+    def as_json(options = nil) #:nodoc:
+      to_i
+    end
+
     protected
 
       def sum(sign, time = ::Time.current) #:nodoc:

data/lib/active_support/file_update_checker.rb

@@ -8,7 +8,7 @@ module ActiveSupport
   #     I18n.reload!
   #   end
   #
-  #   ActionDispatch::Callbacks.to_prepare do
+  #   ActionDispatch::Reloader.to_prepare do
   #     i18n_reloader.execute_if_updated
   #   end
   #

data/lib/active_support/file_watcher.rb

@@ -0,0 +1,36 @@
+module ActiveSupport
+  class FileWatcher
+    class Backend
+      def initialize(path, watcher)
+        @watcher = watcher
+        @path    = path
+      end
+
+      def trigger(files)
+        @watcher.trigger(files)
+      end
+    end
+
+    def initialize
+      @regex_matchers = {}
+    end
+
+    def watch(pattern, &block)
+      @regex_matchers[pattern] = block
+    end
+
+    def trigger(files)
+      trigger_files = Hash.new { |h,k| h[k] = Hash.new { |h2,k2| h2[k2] = [] } }
+
+      files.each do |file, state|
+        @regex_matchers.each do |pattern, block|
+          trigger_files[block][state] << file if pattern === file
+        end
+      end
+
+      trigger_files.each do |block, payload|
+        block.call payload
+      end
+    end
+  end
+end

data/lib/active_support/gzip.rb

@@ -1,6 +1,5 @@
 require 'zlib'
 require 'stringio'
-require 'active_support/core_ext/string/encoding'
 
 module ActiveSupport
   # A convenient wrapper for the zlib standard library that allows compression/decompression of strings with gzip.

data/lib/active_support/hash_with_indifferent_access.rb

@@ -1,7 +1,7 @@
 require 'active_support/core_ext/hash/keys'
 
 # This class has dubious semantics and we only have it so that
-# people can write params[:key] instead of params['key']
+# people can write <tt>params[:key]</tt> instead of <tt>params['key']</tt>
 # and they get the same value for both keys.
 
 module ActiveSupport
@@ -28,7 +28,7 @@ module ActiveSupport
     end
 
     def self.new_from_hash_copying_default(hash)
-      ActiveSupport::HashWithIndifferentAccess.new(hash).tap do |new_hash|
+      new(hash).tap do |new_hash|
         new_hash.default = hash.default
       end
     end
@@ -97,7 +97,9 @@ module ActiveSupport
 
     # Returns an exact copy of the hash.
     def dup
-      HashWithIndifferentAccess.new(self)
+      self.class.new(self).tap do |new_hash|
+        new_hash.default = default
+      end
     end
 
     # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
@@ -107,7 +109,7 @@ module ActiveSupport
     end
 
     # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
-    # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a HashWithDifferentAccess.
+    # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a <tt>HashWithDifferentAccess</tt>.
     def reverse_merge(other_hash)
       super self.class.new_from_hash_copying_default(other_hash)
     end

data/lib/active_support/i18n.rb

@@ -7,4 +7,3 @@ rescue LoadError => e
 end
 
 I18n.load_path << "#{File.dirname(__FILE__)}/locale/en.yml"
-ActiveSupport.run_load_hooks(:i18n)

data/lib/active_support/i18n_railtie.rb

@@ -14,12 +14,12 @@ module I18n
       @reloader ||= ActiveSupport::FileUpdateChecker.new([]){ I18n.reload! }
     end
 
-    # Add I18n::Railtie.reloader to ActionDispatch callbacks. Since, at this
+    # Add <tt>I18n::Railtie.reloader</tt> to ActionDispatch callbacks. Since, at this
     # point, no path was added to the reloader, I18n.reload! is not triggered
     # on to_prepare callbacks. This will only happen on the config.after_initialize
     # callback below.
     initializer "i18n.callbacks" do
-      ActionDispatch::Callbacks.to_prepare do
+      ActionDispatch::Reloader.to_prepare do
         I18n::Railtie.reloader.execute_if_updated
       end
     end

data/lib/active_support/inflector/inflections.rb

@@ -96,7 +96,7 @@ module ActiveSupport
       def clear(scope = :all)
         case scope
           when :all
-            @plurals, @singulars, @uncountables = [], [], []
+            @plurals, @singulars, @uncountables, @humans = [], [], [], []
           else
             instance_variable_set "@#{scope}", []
         end