AdoccaMemcache 0.1.0

data/History.txt

@@ -0,0 +1,5 @@
+== 1.0.0 / 2006-11-13
+
+* 1 major enhancement
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,12 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/adocca_memcache
+lib/adocca_memcache.rb
+lib/am_memcache.rb
+lib/am_action_view.rb
+lib/am_caching.rb
+lib/am_memcache_store.rb
+lib/am_memcache_memoize.rb
+test/test_adocca_memcache.rb

data/README.txt

@@ -0,0 +1,40 @@
+AdoccaMemcache
+    by Adocca AB
+    http://rubyforge.org/projects/adocca-plugins
+
+== DESCRIPTION:
+  
+A client library to simplify usage of memcached within Ruby on Rails projects.
+
+== FEATURES/PROBLEMS:
+  
+* FIX (list of features or problems)
+
+== SYNOPSYS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* FIX (list of requirements)
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== LICENSE:
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+

data/Rakefile

@@ -0,0 +1,15 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/adocca_memcache.rb'
+
+Hoe.new('AdoccaMemcache', '0.1.0') do |p|
+  p.rubyforge_name = 'adocca-plugins'
+  p.summary = 'A client library to simplify using memcached with Ruby on Rails projects.'
+  p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+end
+
+# vim: syntax=Ruby

data/lib/adocca_memcache.rb

@@ -0,0 +1,16 @@
+# Include hook code here
+
+$: << File.dirname(__FILE__)
+
+require_gem 'rails'
+require 'am_action_view.rb'
+require 'am_memcache.rb'
+require 'am_memcache_store.rb'
+require 'am_caching.rb'
+require 'am_memcache_memoize.rb'
+
+ActiveRecord::Base.send(:include, MemcacheMemoize)
+ActiveRecord::Base.send(:extend, MemcacheMemoize)
+ActionView::Base.send(:include, MemcacheMemoize)
+ActionController::Base.send(:include, MemcacheMemoize)
+ActionController::Base.send(:extend, MemcacheMemoize)

data/lib/am_action_view.rb

@@ -0,0 +1,6 @@
+# Customized the Rails own error handling
+ActionView::Base.field_error_proc = Proc.new do |html_tag, instance|
+  msg = instance.error_message
+  title = msg.kind_of?(Array) ? '* ' + msg.join("\n* ") : msg
+  "<span class=\"field-with-errors\">#{html_tag}</span>"
+end

data/lib/am_caching.rb

@@ -0,0 +1,28 @@
+module ActionView
+  module Helpers
+    module CacheHelper
+      def cache_value_erb(basename, expiry=0, args={}, &block)
+        @controller.cache_value_erb(basename, expiry, args, &block)
+      end
+    end
+  end
+end
+module ActionController
+  module Caching
+    module Fragments
+      def cache_value_erb(basename, expiry=0, args={}, &block)        
+        buffer = eval("_erbout", block.binding)
+
+        if cache = cache_read(basename,args)
+          buffer.concat(cache)
+        else
+          pos = buffer.length
+          block.call
+          cache_value(basename, expiry, args) do
+            buffer[pos..-1]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/am_memcache.rb

@@ -0,0 +1,552 @@
+require 'socket'
+require 'thread'
+require 'digest/sha1'
+require 'timeout'
+
+module Adocca
+  
+  #
+  # Extend this module to be able to magically synchronize on any object, just like in Java(tm)!
+  #
+  module Synchronized
+    def synchronize(&block)
+      raise "Adocca::Synchronized::CACHE is not defined!" unless defined?(Adocca::Synchronized::CACHE)
+      Adocca::Synchronized::CACHE.synchronize(self.inspect) do
+        yield
+      end
+    end
+  end
+
+  class NullMutex
+    def synchronize(&block)
+      block.call
+    end
+  end
+
+  #
+  # A Ruby client library for memcached. Ripped from the gem.
+  #
+  class MemCache
+
+    # a semi-unique id for this ruby instance
+    HOST_HASH = Array.new(32).collect do |e| (65 + rand(25)).chr end.join
+
+    # Default options for the cache object.
+    DEFAULT_OPTIONS = {
+      :namespace => nil,
+      :readonly  => false
+    }
+
+    # Default memcached port.
+    DEFAULT_PORT = 11211
+
+    # Default memcached server weight.
+    DEFAULT_WEIGHT = 1
+
+    # The amount of time to wait for a response from a memcached server.  If a
+    # response is not completed within this time, the connection to the server
+    # will be closed and an error will be raised.
+    attr_accessor :request_timeout
+    
+    # Valid options are:
+    #
+    #     :namespace
+    #         If specified, all keys will have the given value prepended
+    #         before accessing the cache.  Defaults to nil.
+    #
+    #     :readonly
+    #         If this is set, any attempt to write to the cache will generate
+    #         an exception.  Defaults to false.
+    # 
+    def initialize(opts = {})
+      opts = DEFAULT_OPTIONS.merge(opts)   
+      @namespace = opts[:namespace]
+      @readonly  = opts[:readonly]
+      if ActionController::Base.allow_concurrency
+        @mutex = Mutex.new
+      else
+        @mutex = NullMutex.new
+      end
+      @servers   = []
+      @buckets   = []
+    end
+
+    # Return a string representation of the cache object.
+    def inspect
+      sprintf("<MemCache: %s servers, %s buckets, ns: %p, ro: %p>",
+              @servers.nitems, @buckets.nitems, @namespace, @readonly)
+    end
+
+    # Returns whether there is at least one active server for the object.
+    def active?
+      not @servers.empty?
+    end
+    
+    # Returns whether the cache was created read only.
+    def readonly?
+      @readonly
+    end
+
+    # Set the servers that the requests will be distributed between.  Entries
+    # can be either strings of the form "hostname:port" or
+    # "hostname:port:weight" or MemCache::Server objects.
+    def servers=(servers)
+      # Create the server objects.
+      @servers = servers.collect do |server|
+        case server
+        when String
+          host, port, weight = server.split(/:/, 3)
+          port ||= DEFAULT_PORT
+          weight ||= DEFAULT_WEIGHT
+          Server::new(host, port, weight)
+        when Server
+          server
+        else
+          raise TypeError, "Cannot convert %s to MemCache::Server" %
+            svr.class.name
+        end
+      end
+
+      # Create an array of server buckets for weight selection of servers.
+      @buckets = []
+      @servers.each do |server|
+        server.weight.times { @buckets.push(server) }
+      end
+    end
+
+    # get an entry from the cache
+    def get(key)
+      cache_key = make_cache_key(key)
+      rval = nil
+      @mutex.synchronize do
+        begin
+          response, sock, server = sock_send_command(cache_key, "get #{cache_key}")
+          return :MemCache_no_such_entry if response =~ /^END/
+
+          v, cache_key, flags, bytes = response.split(/ /)
+          rval = sock.read(bytes.to_i)
+
+          sock.gets
+          sock.gets
+        rescue SystemCallError, IOError => err
+          server.close
+          raise MemCacheError, err.message
+        end
+      end
+
+      if rval.strip.match(/^\d+$/)
+        rval.strip.to_i
+      else
+        # Return the unmarshaled value.
+        begin
+          Marshal.load(rval)
+        rescue ArgumentError, TypeError => err
+          raise MemCacheError, err.message
+        end
+      end
+    end
+
+    #
+    # Invalidate a namespace in the cache.
+    #
+    def invalidate_namespace(ns)
+      inc(make_namespace_key(ns).last)
+    end
+
+    #
+    # Increment an entry in the cache
+    #
+    def inc(key, amount = 1)
+      cache_key = make_cache_key(key)
+      rval = nil
+      @mutex.synchronize do
+        rval = send_command(cache_key, "incr #{cache_key} #{amount}")
+      end
+      rval = rval.strip.to_i if rval =~ /^\d+/
+      rval
+    end
+
+    #
+    # Increment an entry in the cache
+    #
+    def dec(key, amount = 1)
+      cache_key = make_cache_key(key)
+      rval = nil
+      @mutex.synchronize do
+        rval = send_command(cache_key, "decr #{cache_key} #{amount}")
+      end
+      rval = rval.strip.to_i if rval =~ /^\d+/
+      rval
+    end
+
+    # the response when the key is present
+    ADD_NOTSTORED = "NOT_STORED\r\n"
+    # the response when the key is NOT present
+    ADD_STORED = "STORED\r\n"
+
+    # Add an entry to the cache
+    # will return true if the entry didnt already exist
+    def add(key, value, expiry = 0)
+      cache_key = make_cache_key(key)
+      marshaled_value = nil
+      if Integer === value
+        marshaled_value = value.to_s
+      else
+        marshaled_value = Marshal.dump(value)
+      end
+      @mutex.synchronize do
+        send_command(cache_key, "add #{cache_key} 0 #{expiry} #{marshaled_value.size}\r\n" + marshaled_value) == ADD_STORED
+      end
+    end
+
+    # Add an entry to the cache.
+    def set(key, value, expiry = 0)
+      cache_key = make_cache_key(key)
+      marshaled_value = nil
+      if Integer === value
+        marshaled_value = value.to_s
+      else
+        marshaled_value = Marshal.dump(value)
+      end
+      @mutex.synchronize do
+        send_command(cache_key, "set #{cache_key} 0 #{expiry} #{marshaled_value.size}\r\n" + marshaled_value)
+      end
+    end
+
+    # Remove an entry from the cache.
+    # return true if it is deleted
+    def delete(key, expiry = 0)
+      cache_key = make_cache_key(key)
+      @mutex.synchronize do
+        send_command(cache_key, "delete #{cache_key} #{expiry}")
+      end
+    end
+
+    # Reset the connection to all memcache servers.  This should be called if
+    # there is a problem with a cache lookup that might have left the
+    # connection in a corrupted state.
+    def reset
+      @mutex.synchronize do
+        @servers.each { |server| server.close }
+      end
+    end
+    
+    # Method to check if a value is set, and NOT unmarshal, only return bool
+    def check(key)
+      cache_key = make_cache_key(key)
+      @mutex.synchronize do
+
+        begin
+          response, sock, server = sock_send_command(cache_key, "get #{cache_key}")
+          
+          return false if response =~ /^END/
+          
+          v, key, flags, bytes = response.split(/ /)
+          value = sock.read(bytes.to_i)
+          sock.gets
+          sock.gets
+        rescue SystemCallError, IOError => err
+          server.close
+          raise MemCacheError, err.message
+        end
+        
+        true
+      end
+    end
+
+    # Flush cache
+    def flush
+      @mutex.synchronize do
+        raise MemCacheError, "No active servers" unless self.active?
+        @servers.each do |server|
+
+          sock = server.socket
+          if sock.nil?
+            raise MemCacheError, "No connection to server"
+          end
+
+          begin
+            sock.write "flush_all\r\n"
+            sock.gets
+          rescue SystemCallError, IOError => err
+            server.close
+            raise MemCacheError, err.message
+          end
+        end
+      end
+    end
+
+    # lock expiry time
+    TRANS_EXPTIME = 10
+    TRANS_MAX_TRIES = 10
+    
+    # memcache-driven transaction mechanism
+    def synchronize(key)
+      cache_key = make_cache_key(key)
+      tries = 0
+      we_locked_now = false
+      we_locked_earlier = false
+      ok_value = "#{HOST_HASH}:#{Thread.current.object_id}"
+      while (!(we_locked_now = add(cache_key, ok_value, TRANS_EXPTIME)) && 
+             !(we_locked_earlier = (get(cache_key) == ok_value)) &&
+             tries < TRANS_MAX_TRIES)
+        sleep 1
+        tries += 1
+      end
+      if we_locked_now || we_locked_earlier
+        yield
+        self.delete(cache_key) if we_locked_now
+      else
+        raise MemCacheError, "Couldn't obtain lock"
+      end
+    end
+
+    # Shortcut to get a value from the cache.
+    def [](key)
+      self.get(key)
+    end
+
+    # Shortcut to save a value in the cache.  This method does not set an
+    # expiration on the entry.  Use set to specify an explicit expiry.
+    def []=(key, value)
+      self.set(key, value)
+    end
+
+    ###########################################################################
+    # S E R V E R   C L A S S
+    ###########################################################################
+
+    # This class represents a memcached server instance.
+    class Server
+      # The amount of time to wait to establish a connection with a
+      # memcached server.  If a connection cannot be established within
+      # this time limit, the server will be marked as down.
+      CONNECT_TIMEOUT = 0.25
+
+      # The amount of time to wait before attempting to re-establish a
+      # connection with a server that is marked dead.
+      RETRY_DELAY = 30.0
+
+      # The host the memcached server is running on.
+      attr_reader :host
+
+      # The port the memcached server is listening on.
+      attr_reader :port
+
+      # The weight given to the server.
+      attr_reader :weight
+
+      # The time of next retry if the connection is dead.
+      attr_reader :retry
+
+      # A text status string describing the state of the server.
+      attr_reader :status
+      
+      # Create a new MemCache::Server object for the memcached instance
+      # listening on the given host and port, weighted by the given weight.
+      def initialize(host, port = DEFAULT_PORT, weight = DEFAULT_WEIGHT)
+        if host.nil? || host.empty?
+          raise ArgumentError, "No host specified"
+        elsif port.nil? || port.to_i.zero?
+          raise ArgumentError, "No port specified"
+        end
+
+        @host   = host
+        @port   = port.to_i
+        @weight = weight.to_i
+
+        @sock   = nil
+        @retry  = nil
+        @status = "NOT CONNECTED"
+      end
+
+      # Return a string representation of the server object.
+      def inspect
+        sprintf("<MemCache::Server: %s:%d [%d] (%s)>",
+                @host, @port, @weight, @status)
+      end
+
+      # Check whether the server connection is alive.  This will cause the
+      # socket to attempt to connect if it isn't already connected and or if
+      # the server was previously marked as down and the retry time has
+      # been exceeded.
+      def alive?
+        !self.socket.nil?
+      end
+
+      # Try to connect to the memcached server targeted by this object.
+      # Returns the connected socket object on success or nil on failure.
+      def socket
+        # Attempt to connect if not already connected.
+        unless @sock || (!@sock.nil? && @sock.closed?)
+          # If the host was dead, don't retry for a while.
+          if @retry && (@retry > Time::now)
+            @sock = nil
+          else
+            begin
+              @sock = timeout(CONNECT_TIMEOUT) {
+                TCPSocket::new(@host, @port)
+              }
+              @retry  = nil
+              @status = "CONNECTED"
+            rescue SystemCallError, IOError, Timeout::Error => err
+              self.mark_dead(err.message)
+            end
+          end
+        end
+        @sock
+      end
+
+      # Close the connection to the memcached server targeted by this
+      # object.  The server is not considered dead.
+      def close
+        @sock.close if @sock &&!@sock.closed?
+        @sock   = nil
+        @retry  = nil
+        @status = "NOT CONNECTED"
+      end
+
+      # Mark the server as dead and close its socket.
+      def mark_dead(reason = "Unknown error")
+        @sock.close if @sock && !@sock.closed?
+        @sock   = nil
+        @retry  = Time::now + RETRY_DELAY
+        
+        @status = sprintf("DEAD: %s, will retry at %s", reason, @retry)
+      end
+    end
+    
+    
+    ###########################################################################
+    # E X C E P T I O N   C L A S S E S
+    ###########################################################################
+
+    # Base MemCache exception class.
+    class MemCacheError < ::Exception
+    end
+
+    # MemCache internal error class.  Instances of this class mean that there
+    # is some internal error either in the memcache client library or the
+    # memcached server it is talking to.
+    class InternalError < MemCacheError
+    end
+
+    # MemCache client error class.  Instances of this class mean that a
+    # "CLIENT_ERROR" response was seen in the dialog with a memcached server.
+    class ClientError < InternalError
+    end
+
+    # MemCache server error class.  Instances of this class mean that a
+    # "SERVER_ERROR" response was seen in the dialog with a memcached server.
+    class ServerError < InternalError
+      attr_reader :server
+      
+      def initalize(server)
+        @server = server
+      end
+    end
+
+#    private
+
+    #
+    # Will send a command to the proper server for this key
+    # and return the response
+    #
+    def send_command(key, command)
+      sock_send_command(key, command)[0]
+    end
+    
+    #
+    # Will send a command to the proper server for this key
+    # and return the response, socket and server
+    #
+    def sock_send_command(key, command)
+      raise MemCacheError, "No active servers" unless self.active?
+      raise MemCacheError, "Update of readonly cache" if @readonly
+      server = get_server_for_key(key)
+
+      sock = server.socket
+      if sock.nil?
+        raise MemCacheError, "No connection to server"
+      end
+
+      response = nil
+      begin
+        sock.write "#{command}\r\n"
+        [sock.gets, sock, server]
+      rescue SystemCallError, IOError => err
+        server.close
+        raise MemCacheError, err.message
+      end
+    end
+
+    #
+    # Create a key for this namespace and 
+    # return it along with the string you want
+    # to delete or incr to invalidate this specific
+    # namespace
+    #
+    def make_namespace_key(ns, appendage = nil)
+      # ensure that this is an Array
+      ns = ns.to_a
+      # get the first part of the Array
+      next_part = ns.shift
+      # create a unique namespace name of it
+      next_part = [appendage, next_part].join(":") if appendage
+      # create a unique memcache key of the namespace name
+      next_key = "adocca:memcache:namespace:#{next_part}"
+      # make sure it exists in memcache
+      add(next_key, rand(1 << 31))
+      # get its value in memcache
+      salt = get(next_key)
+      if ns.empty?
+        # if this is the last part of the key return it + its secret salt along with itself (for invalidation purposes)
+        ["#{next_part}:#{salt}", next_key]
+      else
+        # otherwise, fetch the rest along with the 
+        last_part = make_namespace_key(ns, next_part)
+        ["#{next_part}:#{salt}:#{last_part.first}", last_part.last]
+      end
+    end
+
+    # Create a key for the cache, incorporating the namespace qualifier if
+    # requested.
+    def make_cache_key(o)
+      if Array === o
+        o = o.clone
+        key = o.pop
+
+        namespace_key = ""
+        namespace_key << ":#{make_namespace_key(o).first}" unless o.empty?
+
+        key = "#{@namespace}#{namespace_key}:#{key}"
+        Digest::SHA1.new(key)
+      else
+        key = "#{@namespace}:#{o}"
+        Digest::SHA1.new(key)
+      end
+    end
+
+    # Pick a server to handle the request based on a hash of the key.
+    def get_server_for_key(key)
+      # Easy enough if there is only one server.
+      return @servers.first if @servers.length == 1
+
+      # Hash the value of the key to select the bucket.
+      hkey = Integer("0x#{key}")
+      
+      # Fetch a server for the given key, retrying if that server is
+      # offline.
+      server = nil
+      20.times do |tries|
+        server = @buckets[(hkey + tries) % @buckets.nitems]
+        break if server.alive?
+      end
+
+      raise MemCacheError, "No servers available" unless server
+      server
+    end
+
+    
+  end
+end

data/lib/am_memcache_memoize.rb

@@ -0,0 +1,110 @@
+module MemcacheMemoize
+
+  # The following is used to cache, using memcache, the results of executing a code block.
+  # The scope of the caching is determined by the basename and the hash args. For instance:
+  #
+  #    cache_value(:unread_messages, 0, :user => @user.id) do
+  #      Messages.find(:all, :conditions => ......).size
+  #    end
+  #
+  # will store the result of the block under the key "unread_messages:user:123" in memcache,
+  # for ever (expiry=0 seconds, meaning no expiration time). The number of hash pairs is
+  # unlimited. Duplicates will be removed.
+  #
+  def cache_value(basename, expiry=0, args={}, &cached_code)
+    return cached_code.call if $DISABLE_CACHE
+    key = compute_memcache_key(basename, args)
+    # Check if the value is cached
+    result = CACHE.get key
+    if result == :MemCache_no_such_entry
+      # No, we need to call the block and cache the result
+      result = cached_code.call
+      CACHE.set key, result, expiry
+      RAILS_DEFAULT_LOGGER.debug "MemCache: Computed and set value for #{key.inspect} (expiry: #{expiry} seconds)"
+    else
+      RAILS_DEFAULT_LOGGER.debug "MemCache: Got #{key.inspect}"
+    end
+    # Return the result
+    result
+  end
+
+  #
+  # Only read a value from memcache
+  #
+
+  def cache_read(basename,  args={})
+    return nil if $DISABLE_CACHE
+    key = compute_memcache_key(basename, args)
+    result = CACHE.get key
+    RAILS_DEFAULT_LOGGER.debug "MemCache: Read #{key.inspect}"
+    if result == :MemCache_no_such_entry
+      nil
+    else
+      result
+    end
+  end
+
+  #
+  # Returns the obj, unless the obj is_a?(ActiveRecord::Base), in which case it will return
+  # the object without associations.
+  #
+  def without_associations(obj)
+    if obj.is_a?(ActiveRecord::Base)
+      obj.remove_associations
+    else
+      obj
+    end
+  end
+
+  #
+  # This method is used to expire cached data. Basename and args are as per cache_value(),
+  # but expiry controls in how many seconds the expiration is to take place. The default
+  # value of 0 means 'immediately'.
+  #
+  def expire_cached_value(basename, expiry=0, args={})
+    key = compute_memcache_key(basename, args)
+    RAILS_DEFAULT_LOGGER.debug "MemCache: Invalidating #{key.inspect}"
+    CACHE.delete key, expiry
+  end
+
+  #
+  # Helper method to invalidate namespaces
+  #
+  def expire_cached_namespace(namespace_string)
+    RAILS_DEFAULT_LOGGER.debug "MemCache: Invalidating namespace: #{namespace_string.to_s}"
+    CACHE.invalidate_namespace(namespace_string)
+  end
+
+  #
+  # Return true if there is such a value in the memcache, otherwise false
+  #
+  def check_cached_value(basename, args={})
+    key = compute_memcache_key(basename, args)
+    rval = CACHE.check(key)
+    RAILS_DEFAULT_LOGGER.debug "MemCache: Checked for #{key.inspect} - returned: " + rval.to_s
+    return rval
+  end
+
+  private
+
+  #
+  # Compute the memcache key string from a basename and a hash
+  #
+  def compute_memcache_key(base, args)
+    key_base = Array(base)
+    # First sort the args so that their order doesn't matter. Also eliminate duplicates.
+    args = (args.sort_by { |key, val| key.to_s }).uniq
+
+    # Construct and return the memcache key string
+    key_base[-1] = key_base.last.to_s << ":" << args.inject("") { |acc, assoc| acc + ':' + assoc[0].to_s + ':' + assoc[1].to_s } unless args.empty?
+
+    key_base
+  end
+end
+
+
+ActiveRecord::Base.send(:include, MemcacheMemoize)
+ActiveRecord::Base.send(:extend, MemcacheMemoize)
+ActionView::Base.send(:include, MemcacheMemoize)
+ActionController::Base.send(:include, MemcacheMemoize)
+ActionController::Base.send(:extend, MemcacheMemoize)

data/lib/am_memcache_store.rb

@@ -0,0 +1,13 @@
+
+class CGI::Session::MemCacheStore
+  def restore
+    begin
+      @session_data = @cache[@session_key]
+      @session_data = {} if @session_data == :MemCache_no_such_entry
+    rescue
+      @session_data = {}
+    end
+    @session_data
+  end
+end
+

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: AdoccaMemcache
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2006-11-13 00:00:00 +01:00
+summary: A client library to simplify using memcached with Ruby on Rails projects.
+require_paths: 
+- lib
+email: ryand-ruby@zenspider.com
+homepage: "    by Adocca AB"
+rubyforge_project: adocca-plugins
+description: "== FEATURES/PROBLEMS:  * FIX (list of features or problems)  == SYNOPSYS:  FIX (code sample of usage)  == REQUIREMENTS:"
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Ryan Davis
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/adocca_memcache
+- lib/adocca_memcache.rb
+- lib/am_memcache.rb
+- lib/am_action_view.rb
+- lib/am_caching.rb
+- lib/am_memcache_store.rb
+- lib/am_memcache_memoize.rb
+- test/test_adocca_memcache.rb
+test_files: 
+- test/test_adocca_memcache.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: 
+- adocca_memcache
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.4
+    version: