activesupport 2.1.2 → 2.2.2

data/lib/active_support/cache/mem_cache_store.rb

@@ -2,8 +2,19 @@ require 'memcache'
 
 module ActiveSupport
   module Cache
+    # A cache store implementation which stores data in Memcached:
+    # http://www.danga.com/memcached/
+    #
+    # This is currently the most popular cache store for production websites.
+    #
+    # Special features:
+    # - Clustering and load balancing. One can specify multiple memcached servers,
+    #   and MemCacheStore will load balance between all available servers. If a
+    #   server goes down, then MemCacheStore will ignore it until it goes back
+    #   online.
+    # - Time-based expiry support. See #write and the +:expires_in+ option.
     class MemCacheStore < Store
-      module Response
+      module Response # :nodoc:
         STORED      = "STORED\r\n"
         NOT_STORED  = "NOT_STORED\r\n"
         EXISTS      = "EXISTS\r\n"
@@ -13,6 +24,14 @@ module ActiveSupport
 
       attr_reader :addresses
 
+      # Creates a new MemCacheStore object, with the given memcached server
+      # addresses. Each address is either a host name, or a host-with-port string
+      # in the form of "host_name:port". For example:
+      #
+      #   ActiveSupport::Cache::MemCacheStore.new("localhost", "server-downstairs.localnetwork:8229")
+      #
+      # If no addresses are specified, then MemCacheStore will connect to
+      # localhost port 11211 (the default memcached port).
       def initialize(*addresses)
         addresses = addresses.flatten
         options = addresses.extract_options!
@@ -21,7 +40,7 @@ module ActiveSupport
         @data = MemCache.new(addresses, options)
       end
 
-      def read(key, options = nil)
+      def read(key, options = nil) # :nodoc:
         super
         @data.get(key, raw?(options))
       rescue MemCache::MemCacheError => e
@@ -29,11 +48,19 @@ module ActiveSupport
         nil
       end
 
-      # Set key = value. Pass :unless_exist => true if you don't 
-      # want to update the cache if the key is already set. 
+      # Writes a value to the cache.
+      #
+      # Possible options:
+      # - +:unless_exist+ - set to true if you don't want to update the cache
+      #   if the key is already set.
+      # - +:expires_in+ - the number of seconds that this value may stay in
+      #   the cache. See ActiveSupport::Cache::Store#write for an example.
       def write(key, value, options = nil)
         super
         method = options && options[:unless_exist] ? :add : :set
+        # memcache-client will break the connection if you send it an integer
+        # in raw mode, so we convert it to a string to be sure it continues working.
+        value = value.to_s if raw?(options)
         response = @data.send(method, key, value, expires_in(options), raw?(options))
         response == Response::STORED
       rescue MemCache::MemCacheError => e
@@ -41,7 +68,7 @@ module ActiveSupport
         false
       end
 
-      def delete(key, options = nil)
+      def delete(key, options = nil) # :nodoc:
         super
         response = @data.delete(key, expires_in(options))
         response == Response::DELETED
@@ -50,39 +77,39 @@ module ActiveSupport
         false
       end
 
-      def exist?(key, options = nil)
+      def exist?(key, options = nil) # :nodoc:
         # Doesn't call super, cause exist? in memcache is in fact a read
         # But who cares? Reading is very fast anyway
         !read(key, options).nil?
       end
 
-      def increment(key, amount = 1)       
+      def increment(key, amount = 1) # :nodoc:
         log("incrementing", key, amount)
-        
-        response = @data.incr(key, amount)  
+
+        response = @data.incr(key, amount)
         response == Response::NOT_FOUND ? nil : response
-      rescue MemCache::MemCacheError 
+      rescue MemCache::MemCacheError
         nil
       end
 
-      def decrement(key, amount = 1)
+      def decrement(key, amount = 1) # :nodoc:
         log("decrement", key, amount)
-        
-        response = data.decr(key, amount) 
+
+        response = @data.decr(key, amount)
         response == Response::NOT_FOUND ? nil : response
-      rescue MemCache::MemCacheError 
+      rescue MemCache::MemCacheError
         nil
-      end        
-      
-      def delete_matched(matcher, options = nil)
+      end
+
+      def delete_matched(matcher, options = nil) # :nodoc:
         super
         raise "Not supported by Memcache"
-      end        
-      
+      end
+
       def clear
         @data.flush_all
-      end        
-      
+      end
+
       def stats
         @data.stats
       end

data/lib/active_support/cache/memory_store.rb

@@ -1,5 +1,19 @@
 module ActiveSupport
   module Cache
+    # A cache store implementation which stores everything into memory in the
+    # same process. If you're running multiple Ruby on Rails server processes
+    # (which is the case if you're using mongrel_cluster or Phusion Passenger),
+    # then this means that your Rails server process instances won't be able
+    # to share cache data with each other. If your application never performs
+    # manual cache item expiry (e.g. when you're using generational cache keys),
+    # then using MemoryStore is ok. Otherwise, consider carefully whether you
+    # should be using this cache store.
+    #
+    # MemoryStore is not only able to store strings, but also arbitrary Ruby
+    # objects.
+    #
+    # MemoryStore is not thread-safe. Use SynchronizedMemoryStore instead
+    # if you need thread-safety.
     class MemoryStore < Store
       def initialize
         @data = {}
@@ -12,7 +26,7 @@ module ActiveSupport
 
       def write(name, value, options = nil)
         super
-        @data[name] = value
+        @data[name] = value.freeze
       end
 
       def delete(name, options = nil)
@@ -35,4 +49,4 @@ module ActiveSupport
       end
     end
   end
-end
+end

data/lib/active_support/cache/synchronized_memory_store.rb

@@ -0,0 +1,47 @@
+module ActiveSupport
+  module Cache
+    # Like MemoryStore, but thread-safe.
+    class SynchronizedMemoryStore < MemoryStore
+      def initialize
+        super
+        @guard = Monitor.new
+      end
+
+      def fetch(key, options = {})
+        @guard.synchronize { super }
+      end
+
+      def read(name, options = nil)
+        @guard.synchronize { super }
+      end
+
+      def write(name, value, options = nil)
+        @guard.synchronize { super }
+      end
+
+      def delete(name, options = nil)
+        @guard.synchronize { super }
+      end
+
+      def delete_matched(matcher, options = nil)
+        @guard.synchronize { super }
+      end
+
+      def exist?(name,options = nil)
+        @guard.synchronize { super }
+      end
+
+      def increment(key, amount = 1)
+        @guard.synchronize { super }
+      end
+
+      def decrement(key, amount = 1)
+        @guard.synchronize { super }
+      end
+
+      def clear
+        @guard.synchronize { super }
+      end
+    end
+  end
+end

data/lib/active_support/callbacks.rb

@@ -96,15 +96,12 @@ module ActiveSupport
         end
       end
 
-      def |(chain)
-        if chain.is_a?(CallbackChain)
-          chain.each { |callback| self | callback }
+      # TODO: Decompose into more Array like behavior
+      def replace_or_append!(chain)
+        if index = index(chain)
+          self[index] = chain
         else
-          if (found_callback = find(chain)) && (index = index(chain))
-            self[index] = chain
-          else
-            self << chain
-          end
+          self << chain
         end
         self
       end
@@ -157,6 +154,14 @@ module ActiveSupport
         self.class.new(@kind, @method, @options.dup)
       end
 
+      def hash
+        if @identifier
+          @identifier.hash
+        else
+          @method.hash
+        end
+      end
+
       def call(*args, &block)
         evaluate_method(method, *args, &block) if should_run_callback?(*args)
       rescue LocalJumpError
@@ -183,7 +188,7 @@ module ActiveSupport
                   "Callbacks must be a symbol denoting the method to call, a string to be evaluated, " +
                   "a block to be invoked, or an object responding to the callback method."
               end
-            end
+          end
         end
 
         def should_run_callback?(*args)

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

@@ -8,6 +8,7 @@ module ActiveSupport #:nodoc:
         #   %w( a b c d ).from(0)  # => %w( a b c d )
         #   %w( a b c d ).from(2)  # => %w( c d )
         #   %w( a b c d ).from(10) # => nil
+        #   %w().from(0)           # => nil
         def from(position)
           self[position..-1]
         end
@@ -17,9 +18,35 @@ module ActiveSupport #:nodoc:
         #   %w( a b c d ).to(0)  # => %w( a )
         #   %w( a b c d ).to(2)  # => %w( a b c )
         #   %w( a b c d ).to(10) # => %w( a b c d )
+        #   %w().to(0)           # => %w()
         def to(position)
           self[0..position]
         end
+
+        # Equal to <tt>self[1]</tt>.
+        def second
+          self[1]
+        end
+
+        # Equal to <tt>self[2]</tt>.
+        def third
+          self[2]
+        end
+
+        # Equal to <tt>self[3]</tt>.
+        def fourth
+          self[3]
+        end
+
+        # Equal to <tt>self[4]</tt>.
+        def fifth
+          self[4]
+        end
+
+        # Equal to <tt>self[41]</tt>. Also known as accessing "the reddit".
+        def forty_two
+          self[41]
+        end
       end
     end
   end

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

@@ -6,10 +6,13 @@ module ActiveSupport #:nodoc:
       module Conversions
         # Converts the array to a comma-separated sentence where the last element is joined by the connector word. Options:
         # * <tt>:connector</tt> - The word used to join the last element in arrays with two or more elements (default: "and")
-        # * <tt>:skip_last_comma</tt> - Set to true to return "a, b and c" instead of "a, b, and c".
-        def to_sentence(options = {})
-          options.assert_valid_keys(:connector, :skip_last_comma)
-          options.reverse_merge! :connector => 'and', :skip_last_comma => false
+        # * <tt>:skip_last_comma</tt> - Set to true to return "a, b and c" instead of "a, b, and c".        
+        def to_sentence(options = {})          
+          options.assert_valid_keys(:connector, :skip_last_comma, :locale)
+          
+          default = I18n.translate(:'support.array.sentence_connector', :locale => options[:locale])
+          default_skip_last_comma = I18n.translate(:'support.array.skip_last_comma', :locale => options[:locale])
+          options.reverse_merge! :connector => default, :skip_last_comma => default_skip_last_comma
           options[:connector] = "#{options[:connector]} " unless options[:connector].nil? || options[:connector].strip == ''
 
           case length
@@ -23,11 +26,12 @@ module ActiveSupport #:nodoc:
               "#{self[0...-1].join(', ')}#{options[:skip_last_comma] ? '' : ','} #{options[:connector]}#{self[-1]}"
           end
         end
+        
 
         # Calls <tt>to_param</tt> on all its elements and joins the result with
         # slashes. This is used by <tt>url_for</tt> in Action Pack. 
         def to_param
-          map(&:to_param).join '/'
+          collect { |e| e.to_param }.join '/'
         end
 
         # Converts an array into a string suitable for use as a URL query string,
@@ -35,7 +39,8 @@ module ActiveSupport #:nodoc:
         #
         #   ['Rails', 'coding'].to_query('hobbies') # => "hobbies%5B%5D=Rails&hobbies%5B%5D=coding"
         def to_query(key)
-          collect { |value| value.to_query("#{key}[]") } * '&'
+          prefix = "#{key}[]"
+          collect { |value| value.to_query(prefix) }.join '&'
         end
 
         def self.included(base) #:nodoc:
@@ -167,7 +172,7 @@ module ActiveSupport #:nodoc:
           else
             xml.tag!(root, options[:skip_types] ? {} : {:type => "array"}) {
               yield xml if block_given?
-              each { |e| e.to_xml(opts.merge!({ :skip_instruct => true })) }
+              each { |e| e.to_xml(opts.merge({ :skip_instruct => true })) }
             }
           end
         end

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

@@ -4,22 +4,22 @@ module ActiveSupport #:nodoc:
   module CoreExtensions #:nodoc:
     module Array #:nodoc:
       module Grouping
-        # Iterates over the array in groups of size +number+, padding any remaining 
-        # slots with +fill_with+ unless it is +false+.
+        # Splits or iterates over the array in groups of size +number+,
+        # padding any remaining slots with +fill_with+ unless it is +false+.
         # 
-        #   %w(1 2 3 4 5 6 7).in_groups_of(3) {|g| p g}
+        #   %w(1 2 3 4 5 6 7).in_groups_of(3) {|group| p group}
         #   ["1", "2", "3"]
         #   ["4", "5", "6"]
         #   ["7", nil, nil]
         #
-        #   %w(1 2 3).in_groups_of(2, ' ') {|g| p g}
+        #   %w(1 2 3).in_groups_of(2, ' ') {|group| p group}
         #   ["1", "2"]
         #   ["3", " "]
         #
-        #   %w(1 2 3).in_groups_of(2, false) {|g| p g}
+        #   %w(1 2 3).in_groups_of(2, false) {|group| p group}
         #   ["1", "2"]
         #   ["3"]
-        def in_groups_of(number, fill_with = nil, &block)
+        def in_groups_of(number, fill_with = nil)
           if fill_with == false
             collection = self
           else
@@ -31,7 +31,7 @@ module ActiveSupport #:nodoc:
           end
 
           if block_given?
-            collection.each_slice(number, &block)
+            collection.each_slice(number) { |slice| yield(slice) }
           else
             returning [] do |groups|
               collection.each_slice(number) { |group| groups << group }
@@ -39,16 +39,59 @@ module ActiveSupport #:nodoc:
           end
         end
 
+        # Splits or iterates over the array in +number+ of groups, padding any
+        # remaining slots with +fill_with+ unless it is +false+.
+        #
+        #   %w(1 2 3 4 5 6 7 8 9 10).in_groups(3) {|group| p group}
+        #   ["1", "2", "3", "4"]
+        #   ["5", "6", "7", nil]
+        #   ["8", "9", "10", nil]
+        #
+        #   %w(1 2 3 4 5 6 7).in_groups(3, '&nbsp;') {|group| p group}
+        #   ["1", "2", "3"]
+        #   ["4", "5", "&nbsp;"]
+        #   ["6", "7", "&nbsp;"]
+        #
+        #   %w(1 2 3 4 5 6 7).in_groups(3, false) {|group| p group}
+        #   ["1", "2", "3"]
+        #   ["4", "5"]
+        #   ["6", "7"]
+        def in_groups(number, fill_with = nil)
+          # size / number gives minor group size;
+          # size % number gives how many objects need extra accomodation;
+          # each group hold either division or division + 1 items.
+          division = size / number
+          modulo = size % number
+
+          # create a new array avoiding dup
+          groups = []
+          start = 0
+
+          number.times do |index|
+            length = division + (modulo > 0 && modulo > index ? 1 : 0)
+            padding = fill_with != false &&
+              modulo > 0 && length == division ? 1 : 0
+            groups << slice(start, length).concat([fill_with] * padding)
+            start += length
+          end
+
+          if block_given?
+            groups.each{|g| yield(g) }
+          else
+            groups
+          end
+        end
+
         # Divides the array into one or more subarrays based on a delimiting +value+
         # or the result of an optional block.
         #
         #   [1, 2, 3, 4, 5].split(3)                # => [[1, 2], [4, 5]]
         #   (1..10).to_a.split { |i| i % 3 == 0 }   # => [[1, 2], [4, 5], [7, 8], [10]]
-        def split(value = nil, &block)
-          block ||= Proc.new { |e| e == value }
+        def split(value = nil)
+          using_block = block_given?
 
           inject([[]]) do |results, element|
-            if block.call(element)
+            if (using_block && yield(element)) || (value == element)
               results << []
             else
               results.last << element