activesupport 4.0.0.beta1 → 4.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 78f08847e1d3d08c65ad482067228990e85ae1aa
-  data.tar.gz: 2267d7e11f8bd76ea6ce4a89ca4f41417ee2778f
+  metadata.gz: 787831cae30c98f2e6f3e06b1ac405a5c5597861
+  data.tar.gz: 34441857e5037fdaa192293f732de973fa362f22
 SHA512:
-  metadata.gz: bf18285e1446e0a6b2a2a7f4986bb331a69032fa1e67d5b8dd12a6c828e46d7321f4360709b05e40c9fb0a45df1a8c68e179583906f769f5f329357b077a2177
-  data.tar.gz: 9364c3e0046164fd3a8789f1a679ea8a43bbaf71b108ac3617536c4b3a28013bb20c02fd9f094a0a71db8886c0b668c8c5af2ad2ebf02a4a0659d8ee9ebc5c12
+  metadata.gz: 2af16317b996dfcdef387e1e8c68fc488b80d85329339c71f640faf69212fb308b2f24723a6134911eddc9358bf87a194363f7bab0997d05ec574ec8345b645e
+  data.tar.gz: c5ea3235e50432543c82825c40e44d34e765d7bb94c5c3b586a179b015f21df62c8fc18458cdb2a63430a6a66db8f72eb58ca68c72000527462241059cf5c2ca

data/CHANGELOG.md

@@ -1,5 +1,52 @@
+## Rails 4.0.0 (unreleased) ##
+
+*   Fix skipping of filters defined by objects in `ActiveSupport::Callbacks::Callback`.
+
+    *Ben McRedmond*
+
+*   An `ActiveSupport::Subscriber` class has been extracted from
+    `ActiveSupport::LogSubscriber`, allowing you to use the event attachment
+    API for other kinds of subscribers.
+
+    *Daniel Schierbeck*
+
+*   `Class#class_attribute` accepts an `instance_predicate` option which
+    defaults to `true`. If set to `false` the predicate method will not
+    be defined.
+
+    *Agis Anastasopoulos*
+
+*   `fast_xs` support has been removed.  Use `String#encode(xml: :attr)`.
+
+*   `ActiveSupport::Notifications::Instrumenter#instrument` should
+    yield its payload.
+
+    *stopdropandrew*
+
+*   `ActiveSupport::TimeWithZone` raises `NoMethodError` in proper context.
+    Fixes #9772.
+
+    *Yves Senn*
+
+*   Fix deletion of empty directories in `ActiveSupport::Cache::FileStore`.
+
+    *Charles Jones*
+
 ## Rails 4.0.0.beta1 (February 25, 2013) ##
 
+*   Improve singularizing a singular for multiple cases.
+    Fixes #2608 #1825 #2395.
+
+    Example:
+
+        # Before
+        'address'.singularize # => 'addres'
+
+        # After
+        'address'.singularize # => 'address'
+
+    *Mark McSpadden*
+
 *   Prevent `DateTime#change` from truncating the second fraction, when seconds
     do not need to be changed.
 

data/README.rdoc

@@ -12,7 +12,7 @@ The latest version of Active Support can be installed with RubyGems:
 
   % [sudo] gem install activesupport
 
-Source code can be downloaded as part of the Rails project on GitHub
+Source code can be downloaded as part of the Rails project on GitHub:
 
 * https://github.com/rails/rails/tree/master/activesupport
 
@@ -26,7 +26,7 @@ Active Support is released under the MIT license:
 
 == Support
 
-API documentation is at
+API documentation is at:
 
 * http://api.rubyonrails.org
 

data/lib/active_support/cache.rb

@@ -56,16 +56,7 @@ module ActiveSupport
 
         case store
         when Symbol
-          store_class_name = store.to_s.camelize
-          store_class =
-            begin
-              require "active_support/cache/#{store}"
-            rescue LoadError => e
-              raise "Could not find cache store adapter for #{store} (#{e})"
-            else
-              ActiveSupport::Cache.const_get(store_class_name)
-            end
-          store_class.new(*parameters)
+          retrieve_store_class(store).new(*parameters)
         when nil
           ActiveSupport::Cache::MemoryStore.new
         else
@@ -73,6 +64,18 @@ module ActiveSupport
         end
       end
 
+      # Expands out the +key+ argument into a key that can be used for the
+      # cache store. Optionally accepts a namespace, and all keys will be
+      # scoped within that namespace.
+      #
+      # If the +key+ argument provided is an array, or responds to +to_a+, then
+      # each of elements in the array will be turned into parameters/keys and
+      # concatenated into a single key. For example:
+      #
+      #   expand_cache_key([:foo, :bar])               # => "foo/bar"
+      #   expand_cache_key([:foo, :bar], "namespace")  # => "namespace/foo/bar"
+      #
+      # The +key+ argument can also respond to +cache_key+ or +to_param+.
       def expand_cache_key(key, namespace = nil)
         expanded_cache_key = namespace ? "#{namespace}/" : ""
 
@@ -94,6 +97,16 @@ module ActiveSupport
         else                                  key.to_param
         end.to_s
       end
+
+      # Obtains the specified cache store class, given the name of the +store+.
+      # Raises an error when the store class cannot be found.
+      def retrieve_store_class(store)
+        require "active_support/cache/#{store}"
+      rescue LoadError => e
+        raise "Could not find cache store adapter for #{store} (#{e})"
+      else
+        ActiveSupport::Cache.const_get(store.to_s.camelize)
+      end
     end
 
     # An abstract cache store class. There are multiple cache store
@@ -344,7 +357,7 @@ module ActiveSupport
       # Options are passed to the underlying cache implementation.
       def write(name, value, options = nil)
         options = merged_options(options)
-        instrument(:write, name, options) do |payload|
+        instrument(:write, name, options) do
           entry = Entry.new(value, options)
           write_entry(namespaced_key(name, options), entry, options)
         end
@@ -355,7 +368,7 @@ module ActiveSupport
       # Options are passed to the underlying cache implementation.
       def delete(name, options = nil)
         options = merged_options(options)
-        instrument(:delete, name) do |payload|
+        instrument(:delete, name) do
           delete_entry(namespaced_key(name, options), options)
         end
       end
@@ -365,7 +378,7 @@ module ActiveSupport
       # Options are passed to the underlying cache implementation.
       def exist?(name, options = nil)
         options = merged_options(options)
-        instrument(:exist?, name) do |payload|
+        instrument(:exist?, name) do
           entry = read_entry(namespaced_key(name, options), options)
           entry && !entry.expired?
         end
@@ -522,7 +535,7 @@ module ActiveSupport
         def handle_expired_entry(entry, key, options)
           if entry && entry.expired?
             race_ttl = options[:race_condition_ttl].to_i
-            if race_ttl && (Time.now - entry.expires_at <= race_ttl)
+            if race_ttl && (Time.now.to_f - entry.expires_at <= race_ttl)
               # When an entry has :race_condition_ttl defined, put the stale entry back into the cache
               # for a brief period while the entry is begin recalculated.
               entry.expires_at = Time.now + race_ttl
@@ -562,38 +575,38 @@ module ActiveSupport
       # +:compress+, +:compress_threshold+, and +:expires_in+.
       def initialize(value, options = {})
         if should_compress?(value, options)
-          @v = compress(value)
-          @c = true
+          @value = compress(value)
+          @compressed = true
         else
-          @v = value
-        end
-        if expires_in = options[:expires_in]
-          @x = (Time.now + expires_in).to_i
+          @value = value
         end
+        @created_at = Time.now.to_f
+        @expires_in = options[:expires_in]
+        @expires_in = @expires_in.to_f if @expires_in
       end
 
       def value
-        convert_version_3_entry! if defined?(@value)
-        compressed? ? uncompress(@v) : @v
+        convert_version_4beta1_entry! if defined?(@v)
+        compressed? ? uncompress(@value) : @value
       end
 
       # Check if the entry is expired. The +expires_in+ parameter can override
       # the value set when the entry was created.
       def expired?
-        convert_version_3_entry! if defined?(@value)
-        if defined?(@x)
-          @x && @x < Time.now.to_i
-        else
-          false
-        end
+        convert_version_4beta1_entry! if defined?(@value)
+        @expires_in && @created_at + @expires_in <= Time.now.to_f
       end
 
       def expires_at
-        Time.at(@x) if defined?(@x)
+        @expires_in ? @created_at + @expires_in : nil
       end
 
       def expires_at=(value)
-        @x = value.to_i
+        if value
+          @expires_in = value.to_f - @created_at
+        else
+          @expires_in = nil
+        end
       end
 
       # Returns the size of the cached value. This could be less than
@@ -606,9 +619,9 @@ module ActiveSupport
           when NilClass
             0
           when String
-            @v.bytesize
+            @value.bytesize
           else
-            @s = Marshal.dump(@v).bytesize
+            @s = Marshal.dump(@value).bytesize
           end
         end
       end
@@ -616,12 +629,12 @@ module ActiveSupport
       # Duplicate the value in a class. This is used by cache implementations that don't natively
       # serialize entries to protect against accidental cache modifications.
       def dup_value!
-        convert_version_3_entry! if defined?(@value)
-        if @v && !compressed? && !(@v.is_a?(Numeric) || @v == true || @v == false)
-          if @v.is_a?(String)
-            @v = @v.dup
+        convert_version_4beta1_entry! if defined?(@v)
+        if @value && !compressed? && !(@value.is_a?(Numeric) || @value == true || @value == false)
+          if @value.is_a?(String)
+            @value = @value.dup
           else
-            @v = Marshal.load(Marshal.dump(@v))
+            @value = Marshal.load(Marshal.dump(@value))
           end
         end
       end
@@ -637,7 +650,7 @@ module ActiveSupport
         end
 
         def compressed?
-          defined?(@c) ? @c : false
+          defined?(@compressed) ? @compressed : false
         end
 
         def compress(value)
@@ -650,19 +663,19 @@ module ActiveSupport
 
         # The internals of this method changed between Rails 3.x and 4.0. This method provides the glue
         # to ensure that cache entries created under the old version still work with the new class definition.
-        def convert_version_3_entry!
-          if defined?(@value)
-            @v = @value
-            remove_instance_variable(:@value)
+        def convert_version_4beta1_entry!
+          if defined?(@v)
+            @value = @v
+            remove_instance_variable(:@v)
           end
-          if defined?(@compressed)
-            @c = @compressed
-            remove_instance_variable(:@compressed)
+          if defined?(@c)
+            @compressed = @c
+            remove_instance_variable(:@c)
           end
-          if defined?(@expires_in) && defined?(@created_at) && @expires_in && @created_at
-            @x = (@created_at + @expires_in).to_i
-            remove_instance_variable(:@created_at)
-            remove_instance_variable(:@expires_in)
+          if defined?(@x) && @x
+            @created_at ||= Time.now.to_f
+            @expires_in = @x - @created_at
+            remove_instance_variable(:@x)
           end
         end
     end

data/lib/active_support/cache/file_store.rb

@@ -150,9 +150,9 @@ module ActiveSupport
 
         # Delete empty directories in the cache.
         def delete_empty_directories(dir)
-          return if dir == cache_path
+          return if File.realpath(dir) == File.realpath(cache_path)
           if Dir.entries(dir).reject {|f| EXCLUDED_DIRS.include?(f)}.empty?
-            File.delete(dir) rescue nil
+            Dir.delete(dir) rescue nil
             delete_empty_directories(File.dirname(dir))
           end
         end

data/lib/active_support/cache/strategy/local_cache.rb

@@ -8,6 +8,23 @@ module ActiveSupport
       # duration of a block. Repeated calls to the cache for the same key will hit the
       # in-memory cache for faster access.
       module LocalCache
+        # Class for storing and registering the local caches.
+        class LocalCacheRegistry # :nodoc:
+          extend ActiveSupport::PerThreadRegistry
+
+          def initialize
+            @registry = {}
+          end
+
+          def cache_for(local_cache_key)
+            @registry[local_cache_key]
+          end
+
+          def set_cache_for(local_cache_key, value)
+            @registry[local_cache_key] = value
+          end
+        end
+
         # Simple memory backed cache. This cache is not thread safe and is intended only
         # for serving as a temporary memory cache for a single thread.
         class LocalStore < Store
@@ -41,24 +58,18 @@ module ActiveSupport
 
         # Use a local cache for the duration of block.
         def with_local_cache
-          save_val = Thread.current[thread_local_key]
-          begin
-            Thread.current[thread_local_key] = LocalStore.new
-            yield
-          ensure
-            Thread.current[thread_local_key] = save_val
-          end
+          use_temporary_local_cache(LocalStore.new) { yield }
         end
 
         #--
         # This class wraps up local storage for middlewares. Only the middleware method should
         # construct them.
         class Middleware # :nodoc:
-          attr_reader :name, :thread_local_key
+          attr_reader :name, :local_cache_key
 
-          def initialize(name, thread_local_key)
+          def initialize(name, local_cache_key)
             @name             = name
-            @thread_local_key = thread_local_key
+            @local_cache_key = local_cache_key
             @app              = nil
           end
 
@@ -68,10 +79,10 @@ module ActiveSupport
           end
 
           def call(env)
-            Thread.current[thread_local_key] = LocalStore.new
+            LocalCacheRegistry.set_cache_for(local_cache_key, LocalStore.new)
             @app.call(env)
           ensure
-            Thread.current[thread_local_key] = nil
+            LocalCacheRegistry.set_cache_for(local_cache_key, nil)
           end
         end
 
@@ -80,7 +91,7 @@ module ActiveSupport
         def middleware
           @middleware ||= Middleware.new(
             "ActiveSupport::Cache::Strategy::LocalCache",
-            thread_local_key)
+            local_cache_key)
         end
 
         def clear(options = nil) # :nodoc:
@@ -95,29 +106,13 @@ module ActiveSupport
 
         def increment(name, amount = 1, options = nil) # :nodoc:
           value = bypass_local_cache{super}
-          if local_cache
-            local_cache.mute do
-              if value
-                local_cache.write(name, value, options)
-              else
-                local_cache.delete(name, options)
-              end
-            end
-          end
+          increment_or_decrement(value, name, amount, options)
           value
         end
 
         def decrement(name, amount = 1, options = nil) # :nodoc:
           value = bypass_local_cache{super}
-          if local_cache
-            local_cache.mute do
-              if value
-                local_cache.write(name, value, options)
-              else
-                local_cache.delete(name, options)
-              end
-            end
-          end
+          increment_or_decrement(value, name, amount, options)
           value
         end
 
@@ -146,21 +141,37 @@ module ActiveSupport
           end
 
         private
-          def thread_local_key
-            @thread_local_key ||= "#{self.class.name.underscore}_local_cache_#{object_id}".gsub(/[\/-]/, '_').to_sym
+          def increment_or_decrement(value, name, amount, options)
+            if local_cache
+              local_cache.mute do
+                if value
+                  local_cache.write(name, value, options)
+                else
+                  local_cache.delete(name, options)
+                end
+              end
+            end
+          end
+
+          def local_cache_key
+            @local_cache_key ||= "#{self.class.name.underscore}_local_cache_#{object_id}".gsub(/[\/-]/, '_').to_sym
           end
 
           def local_cache
-            Thread.current[thread_local_key]
+            LocalCacheRegistry.cache_for(local_cache_key)
           end
 
           def bypass_local_cache
-            save_cache = Thread.current[thread_local_key]
+            use_temporary_local_cache(nil) { yield }
+          end
+
+          def use_temporary_local_cache(temporary_cache)
+            save_cache = LocalCacheRegistry.cache_for(local_cache_key)
             begin
-              Thread.current[thread_local_key] = nil
+              LocalCacheRegistry.set_cache_for(local_cache_key, temporary_cache)
               yield
             ensure
-              Thread.current[thread_local_key] = save_cache
+              LocalCacheRegistry.set_cache_for(local_cache_key, save_cache)
             end
           end
       end