mack-active_record 0.8.2 → 0.8.3

data/lib/gems/activesupport-2.2.2/lib/active_support/cache/drb_store.rb

@@ -1,15 +0,0 @@
-require 'drb'
-
-module ActiveSupport
-  module Cache
-    class DRbStore < MemoryStore #:nodoc:
-      attr_reader :address
-
-      def initialize(address = 'druby://localhost:9192')
-        super()
-        @address = address
-        @data = DRbObject.new(nil, address)
-      end
-    end
-  end
-end

data/lib/gems/activesupport-2.2.2/lib/active_support/cache/file_store.rb

@@ -1,72 +0,0 @@
-module ActiveSupport
-  module Cache
-    # A cache store implementation which stores everything on the filesystem.
-    class FileStore < Store
-      attr_reader :cache_path
-
-      def initialize(cache_path)
-        @cache_path = cache_path
-      end
-
-      def read(name, options = nil)
-        super
-        File.open(real_file_path(name), 'rb') { |f| Marshal.load(f) } rescue nil
-      end
-
-      def write(name, value, options = nil)
-        super
-        ensure_cache_path(File.dirname(real_file_path(name)))
-        File.atomic_write(real_file_path(name), cache_path) { |f| Marshal.dump(value, f) }
-        value
-      rescue => e
-        logger.error "Couldn't create cache directory: #{name} (#{e.message})" if logger
-      end
-
-      def delete(name, options = nil)
-        super
-        File.delete(real_file_path(name))
-      rescue SystemCallError => e
-        # If there's no cache, then there's nothing to complain about
-      end
-
-      def delete_matched(matcher, options = nil)
-        super
-        search_dir(@cache_path) do |f|
-          if f =~ matcher
-            begin
-              File.delete(f)
-            rescue SystemCallError => e
-              # If there's no cache, then there's nothing to complain about
-            end
-          end
-        end
-      end
-
-      def exist?(name, options = nil)
-        super
-        File.exist?(real_file_path(name))
-      end
-
-      private
-        def real_file_path(name)
-          '%s/%s.cache' % [@cache_path, name.gsub('?', '.').gsub(':', '.')]
-        end
-
-        def ensure_cache_path(path)
-          FileUtils.makedirs(path) unless File.exist?(path)
-        end
-
-        def search_dir(dir, &callback)
-          Dir.foreach(dir) do |d|
-            next if d == "." || d == ".."
-            name = File.join(dir, d)
-            if File.directory?(name)
-              search_dir(name, &callback)
-            else
-              callback.call name
-            end
-          end
-        end
-    end
-  end
-end

data/lib/gems/activesupport-2.2.2/lib/active_support/cache/mem_cache_store.rb

@@ -1,127 +0,0 @@
-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 # :nodoc:
-        STORED      = "STORED\r\n"
-        NOT_STORED  = "NOT_STORED\r\n"
-        EXISTS      = "EXISTS\r\n"
-        NOT_FOUND   = "NOT_FOUND\r\n"
-        DELETED     = "DELETED\r\n"
-      end
-
-      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!
-        addresses = ["localhost"] if addresses.empty?
-        @addresses = addresses
-        @data = MemCache.new(addresses, options)
-      end
-
-      def read(key, options = nil) # :nodoc:
-        super
-        @data.get(key, raw?(options))
-      rescue MemCache::MemCacheError => e
-        logger.error("MemCacheError (#{e}): #{e.message}")
-        nil
-      end
-
-      # 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
-        logger.error("MemCacheError (#{e}): #{e.message}")
-        false
-      end
-
-      def delete(key, options = nil) # :nodoc:
-        super
-        response = @data.delete(key, expires_in(options))
-        response == Response::DELETED
-      rescue MemCache::MemCacheError => e
-        logger.error("MemCacheError (#{e}): #{e.message}")
-        false
-      end
-
-      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) # :nodoc:
-        log("incrementing", key, amount)
-
-        response = @data.incr(key, amount)
-        response == Response::NOT_FOUND ? nil : response
-      rescue MemCache::MemCacheError
-        nil
-      end
-
-      def decrement(key, amount = 1) # :nodoc:
-        log("decrement", key, amount)
-
-        response = @data.decr(key, amount)
-        response == Response::NOT_FOUND ? nil : response
-      rescue MemCache::MemCacheError
-        nil
-      end
-
-      def delete_matched(matcher, options = nil) # :nodoc:
-        super
-        raise "Not supported by Memcache"
-      end
-
-      def clear
-        @data.flush_all
-      end
-
-      def stats
-        @data.stats
-      end
-
-      private
-        def expires_in(options)
-          (options && options[:expires_in]) || 0
-        end
-
-        def raw?(options)
-          options && options[:raw]
-        end
-    end
-  end
-end

data/lib/gems/activesupport-2.2.2/lib/active_support/cache/memory_store.rb

@@ -1,52 +0,0 @@
-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 = {}
-      end
-
-      def read(name, options = nil)
-        super
-        @data[name]
-      end
-
-      def write(name, value, options = nil)
-        super
-        @data[name] = value.freeze
-      end
-
-      def delete(name, options = nil)
-        super
-        @data.delete(name)
-      end
-
-      def delete_matched(matcher, options = nil)
-        super
-        @data.delete_if { |k,v| k =~ matcher }
-      end
-
-      def exist?(name,options = nil)
-        super
-        @data.has_key?(name)
-      end
-
-      def clear
-        @data.clear
-      end
-    end
-  end
-end

data/lib/gems/activesupport-2.2.2/lib/active_support/cache/synchronized_memory_store.rb

@@ -1,47 +0,0 @@
-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/gems/activesupport-2.2.2/lib/active_support/cache.rb

@@ -1,223 +0,0 @@
-require 'benchmark'
-
-module ActiveSupport
-  # See ActiveSupport::Cache::Store for documentation.
-  module Cache
-    # Creates a new CacheStore object according to the given options.
-    #
-    # If no arguments are passed to this method, then a new
-    # ActiveSupport::Cache::MemoryStore object will be returned.
-    #
-    # If you pass a Symbol as the first argument, then a corresponding cache
-    # store class under the ActiveSupport::Cache namespace will be created.
-    # For example:
-    #
-    #   ActiveSupport::Cache.lookup_store(:memory_store)
-    #   # => returns a new ActiveSupport::Cache::MemoryStore object
-    #   
-    #   ActiveSupport::Cache.lookup_store(:drb_store)
-    #   # => returns a new ActiveSupport::Cache::DRbStore object
-    #
-    # Any additional arguments will be passed to the corresponding cache store
-    # class's constructor:
-    #
-    #   ActiveSupport::Cache.lookup_store(:file_store, "/tmp/cache")
-    #   # => same as: ActiveSupport::Cache::FileStore.new("/tmp/cache")
-    #
-    # If the first argument is not a Symbol, then it will simply be returned:
-    #
-    #   ActiveSupport::Cache.lookup_store(MyOwnCacheStore.new)
-    #   # => returns MyOwnCacheStore.new
-    def self.lookup_store(*store_option)
-      store, *parameters = *([ store_option ].flatten)
-
-      case store
-      when Symbol
-        store_class_name = (store == :drb_store ? "DRbStore" : store.to_s.camelize)
-        store_class = ActiveSupport::Cache.const_get(store_class_name)
-        store_class.new(*parameters)
-      when nil
-        ActiveSupport::Cache::MemoryStore.new
-      else
-        store
-      end
-    end
-
-    def self.expand_cache_key(key, namespace = nil)
-      expanded_cache_key = namespace ? "#{namespace}/" : ""
-
-      if ENV["RAILS_CACHE_ID"] || ENV["RAILS_APP_VERSION"]
-        expanded_cache_key << "#{ENV["RAILS_CACHE_ID"] || ENV["RAILS_APP_VERSION"]}/"
-      end
-
-      expanded_cache_key << case
-        when key.respond_to?(:cache_key)
-          key.cache_key
-        when key.is_a?(Array)
-          key.collect { |element| expand_cache_key(element) }.to_param
-        when key
-          key.to_param
-        end.to_s
-
-      expanded_cache_key
-    end
-
-    # An abstract cache store class. There are multiple cache store
-    # implementations, each having its own additional features. See the classes
-    # under the ActiveSupport::Cache module, e.g.
-    # ActiveSupport::Cache::MemCacheStore. MemCacheStore is currently the most
-    # popular cache store for large production websites.
-    #
-    # ActiveSupport::Cache::Store is meant for caching strings. Some cache
-    # store implementations, like MemoryStore, are able to cache arbitrary
-    # Ruby objects, but don't count on every cache store to be able to do that.
-    #
-    #   cache = ActiveSupport::Cache::MemoryStore.new
-    #   
-    #   cache.read("city")   # => nil
-    #   cache.write("city", "Duckburgh")
-    #   cache.read("city")   # => "Duckburgh"
-    class Store
-      cattr_accessor :logger
-
-      def silence!
-        @silence = true
-        self
-      end
-
-      # Fetches data from the cache, using the given key. If there is data in
-      # the cache with the given key, then that data is returned.
-      #
-      # If there is no such data in the cache (a cache miss occurred), then
-      # then nil will be returned. However, if a block has been passed, then
-      # that block will be run in the event of a cache miss. The return value
-      # of the block will be written to the cache under the given cache key,
-      # and that return value will be returned.
-      #
-      #   cache.write("today", "Monday")
-      #   cache.fetch("today")  # => "Monday"
-      #   
-      #   cache.fetch("city")   # => nil
-      #   cache.fetch("city") do
-      #     "Duckburgh"
-      #   end
-      #   cache.fetch("city")   # => "Duckburgh"
-      #
-      # You may also specify additional options via the +options+ argument.
-      # Setting <tt>:force => true</tt> will force a cache miss:
-      #
-      #   cache.write("today", "Monday")
-      #   cache.fetch("today", :force => true)  # => nil
-      #
-      # Other options will be handled by the specific cache store implementation.
-      # Internally, #fetch calls #read, and calls #write on a cache miss.
-      # +options+ will be passed to the #read and #write calls.
-      #
-      # For example, MemCacheStore's #write method supports the +:expires_in+
-      # option, which tells the memcached server to automatically expire the
-      # cache item after a certain period. We can use this option with #fetch
-      # too:
-      #
-      #   cache = ActiveSupport::Cache::MemCacheStore.new
-      #   cache.fetch("foo", :force => true, :expires_in => 5.seconds) do
-      #     "bar"
-      #   end
-      #   cache.fetch("foo")  # => "bar"
-      #   sleep(6)
-      #   cache.fetch("foo")  # => nil
-      def fetch(key, options = {})
-        @logger_off = true
-        if !options[:force] && value = read(key, options)
-          @logger_off = false
-          log("hit", key, options)
-          value
-        elsif block_given?
-          @logger_off = false
-          log("miss", key, options)
-
-          value = nil
-          seconds = Benchmark.realtime { value = yield }
-
-          @logger_off = true
-          write(key, value, options)
-          @logger_off = false
-
-          log("write (will save #{'%.2f' % (seconds * 1000)}ms)", key, nil)
-
-          value
-        end
-      end
-
-      # Fetches data from the cache, using the given key. If there is data in
-      # the cache with the given key, then that data is returned. Otherwise,
-      # nil is returned.
-      #
-      # You may also specify additional options via the +options+ argument.
-      # The specific cache store implementation will decide what to do with
-      # +options+.
-      def read(key, options = nil)
-        log("read", key, options)
-      end
-
-      # Writes the given value to the cache, with the given key.
-      #
-      # You may also specify additional options via the +options+ argument.
-      # The specific cache store implementation will decide what to do with
-      # +options+.
-      # 
-      # For example, MemCacheStore supports the +:expires_in+ option, which
-      # tells the memcached server to automatically expire the cache item after
-      # a certain period:
-      #
-      #   cache = ActiveSupport::Cache::MemCacheStore.new
-      #   cache.write("foo", "bar", :expires_in => 5.seconds)
-      #   cache.read("foo")  # => "bar"
-      #   sleep(6)
-      #   cache.read("foo")  # => nil
-      def write(key, value, options = nil)
-        log("write", key, options)
-      end
-
-      def delete(key, options = nil)
-        log("delete", key, options)
-      end
-
-      def delete_matched(matcher, options = nil)
-        log("delete matched", matcher.inspect, options)
-      end
-
-      def exist?(key, options = nil)
-        log("exist?", key, options)
-      end
-
-      def increment(key, amount = 1)
-        log("incrementing", key, amount)
-        if num = read(key)
-          write(key, num + amount)
-        else
-          nil
-        end
-      end
-
-      def decrement(key, amount = 1)
-        log("decrementing", key, amount)
-        if num = read(key)
-          write(key, num - amount)
-        else
-          nil
-        end
-      end
-
-      private
-        def log(operation, key, options)
-          logger.debug("Cache #{operation}: #{key}#{options ? " (#{options.inspect})" : ""}") if logger && !@silence && !@logger_off
-        end
-    end
-  end
-end
-
-require 'active_support/cache/file_store'
-require 'active_support/cache/memory_store'
-require 'active_support/cache/drb_store'
-require 'active_support/cache/mem_cache_store'
-require 'active_support/cache/compressed_mem_cache_store'