jruby-memcache-client 1.6.0

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+nbproject/private

data/MIT-LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2008 Abhi Yerra <abhi@traytwo.com>
+Copyright (c) 2009 Ikai Lan <ikai.lan@gmail.com>
+Copyright (c) 2009 Tiago Bastos <comechao@gmail.com>
+Copyright (c) 2009 Frederic Jean <frederic.jean@sun.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README

@@ -0,0 +1,69 @@
+This projects provides memcached based stores for JRuby. It is a gem based on Ikai Lan's jruby-memcache-client project hosted at http://github.com/ikai/jruby-memcache-client/tree
+
+This project is a JRuby wrapper of the Java MemCache library by Greg Whalin
+
+http://www.whalin.com/memcached/
+
+In production, the standard Ruby MemCache client can cause a thread to hang. In the Glassfish application server, by default there are 5 Grizzly connectors that handle incoming requests. A site that uses MemCache heavily can quickly cause all Grizzly connectors to block and take down a site. I'm hoping that this work I am doing here will help others adopt JRuby as a production platform for their Ruby on Rails applications.
+
+The Ruby MemCache library was never written with threaded applications in mind. All threads use the same socket, and multithreaded mode basically wraps the IO with a Mutex. The Java library provides several features that are not available in the Ruby MemCache library:
+
+- connection pooling
+- socket timeouts. In forks of the Ruby MemCache library this is achieved either with a Mongrel timeout or use of the Ruby Timeout class, which, at least at the writing of this README, will work unpredictably when being used as a failsafe against hanging IO.
+
+As of right now this code only provides a very minimal amount of functionality, but it is enough to use with the Rails cache and cache_fu.
+
+Installation
+------------
+This is a ruby gem that can be installed.
+
+gem sources -a http://gems.github.com
+gem install ikai-jruby-memcache-client --remote
+
+Replacing Rail's MemCache Client
+--------------------------------
+
+Rails ships with a bundled copy of the MemCache client. This client will prevent you from using this gem instead. Adding the following code into your environment.rb file:
+
+if RUBY_PLATFORM =~ /java/i
+  # Based on instructions from http://www.mikeperham.com/2009/03/03/using-memcache-client-16x-in-rails-23/
+  # Brain surgery to use our own version of memcache-client without
+  # having to modify activesupport directly.
+  # Unload any previous instance of the class
+  if Object.const_defined? :MemCache
+    Object.instance_eval { remove_const :MemCache }
+  end
+  # Pull in the exact version we want
+  gem 'ikai-jruby-memcache-client', '1.5.0'
+
+  # Ensure that the memcache-client path is at the front of the loadpath
+  $LOAD_PATH.each do |path|
+    if path =~ /ikai-jruby-memcache-client/
+      $LOAD_PATH.delete(path)
+      $LOAD_PATH.unshift(path)
+    end
+  end
+  # If Ruby thinks it's already loaded memcache.rb, force
+  # a reload otherwise just require.
+  if $".find { |file| file =~ /\Amemcache.rb\Z/ }
+    load 'memcache.rb'
+  else
+    require 'memcache'
+  end
+end
+
+This will remove the original MemCache client and load our version of the MemCache class instead.
+
+Configuration
+-------------
+The JRuby MemCache client uses the same configuration options as the regular MemCache client. Here is how to build the configuration in your environment.rb file:
+
+memcache_options = {
+  :namespace => 'fortaleza:production_live:',
+}
+memcached_servers = [ ENV['MEMCACHED_LOCATION'] || '0.0.0.0:11211']
+
+# Constant used by libs
+CACHE = MemCache.new memcached_servers, memcache_options if RUBY_PLATFORM =~ /java/
+
+Note that this may vary based on your particular configuration method and environment.

data/Rakefile

@@ -0,0 +1,28 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "jruby-memcache-client"
+    gemspec.summary = "A drop in replacement for Ruby's memcache-client."
+    gemspec.email = "abhi@traytwo.com"
+    gemspec.homepage = "http://github.com/abhiyerra/jruby-memcache-client"
+    gemspec.description = "A drop in replacement for Ruby's memcache-client."
+    gemspec.authors = ["Abhi Yerra", "Ikai Lan", "Frederic Jean", "Lennon Day-Reynolds"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+if RUBY_PLATFORM =~ /java/i
+  begin
+    require 'spec/rake/spectask'
+    
+    task :default => :spec
+    
+    desc "Run the specs for the jruby-memcache-client gem"
+    Spec::Rake::SpecTask.new
+  rescue LoadError
+    puts "You must have rspec installed in order to run the tests."
+  end
+else
+  puts "You must run rake under JRuby."
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+---
+:minor: 6
+:major: 1
+:patch: 0

data/jruby-memcache-client.gemspec

@@ -0,0 +1,45 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{jruby-memcache-client}
+  s.version = "1.6.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Abhi Yerra", "Ikai Lan", "Frederic Jean", "Lennon Day-Reynolds"]
+  s.date = %q{2009-05-20}
+  s.description = %q{A drop in replacement for Ruby's memcache-client.}
+  s.email = %q{abhi@traytwo.com}
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    ".gitignore",
+     "MIT-LICENSE",
+     "README",
+     "Rakefile",
+     "VERSION.yml",
+     "jruby-memcache-client.gemspec",
+     "lib/java/java_memcached-release_2.0.1.jar",
+     "lib/memcache.rb",
+     "spec/jruby_memcache_spec.rb"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/ikai/jruby-memcache-client}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{A drop in replacement for Ruby's memcache-client.}
+  s.test_files = [
+    "spec/jruby_memcache_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/lib/memcache.rb

@@ -0,0 +1,306 @@
+require 'java'
+
+require File.dirname(__FILE__) + '/java/java_memcached-release_2.0.1.jar'
+
+class MemCache
+  include_class 'com.danga.MemCached.MemCachedClient'
+  include_class 'com.danga.MemCached.SockIOPool'
+
+  VERSION = '1.6.0'
+
+  ##
+  # Default options for the cache object.
+
+  DEFAULT_OPTIONS = {
+    :namespace   => nil,
+    :readonly    => false,
+    :multithread => true,
+    :pool_initial_size => 5,
+    :pool_min_size => 5,
+    :pool_max_size => 250,
+    :pool_max_idle => (1000 * 60 * 60 * 6),
+    :pool_maintenance_thread_sleep => 30,
+    :pool_use_nagle => false,
+    :pool_socket_timeout => 3000,
+    :pool_socket_connect_timeout => 3000,
+    :pool_name => 'default'
+  }
+
+  ## CHARSET for Marshalling
+  MARSHALLING_CHARSET = 'UTF-8'
+
+  ##
+  # Default memcached port.
+
+  DEFAULT_PORT = 11211
+
+  ##
+  # Default memcached server weight.
+
+  DEFAULT_WEIGHT = 1
+
+  attr_accessor :request_timeout
+
+  ##
+  # The namespace for this instance
+
+  attr_reader :namespace
+
+  ##
+  # The multithread setting for this instance
+
+  attr_reader :multithread
+
+  ##
+  # The configured socket pool name for this client.
+  attr_reader :pool_name
+
+  ##
+  # Configures the client
+  def initialize(*args)
+    @servers = []
+    opts = {}
+
+    case args.length
+    when 0 then # NOP
+    when 1 then
+      arg = args.shift
+      case arg
+      when Hash   then opts = arg
+      when Array  then @servers = arg
+      when String then @servers = [arg]
+      else raise ArgumentError, 'first argument must be Array, Hash or String'
+      end
+    when 2 then
+      @servers, opts = args
+      @servers = [@servers].flatten
+    else
+      raise ArgumentError, "wrong number of arguments (#{args.length} for 2)"
+    end
+
+    opts = DEFAULT_OPTIONS.merge opts
+
+    @namespace = opts[:namespace] || opts["namespace"]
+    @pool_name = opts[:pool_name] || opts["pool_name"]
+    @readonly = opts[:readonly] || opts["readonly"]
+
+    @client = MemCachedClient.new(@pool_name)
+
+    @client.primitiveAsString = true
+    @client.sanitizeKeys = false
+
+    weights = Array.new(@servers.size, DEFAULT_WEIGHT)
+
+    @pool = SockIOPool.getInstance(@pool_name)
+    unless @pool.initialized?
+      # // set the servers and the weights
+      @pool.servers = @servers.to_java(:string)
+      @pool.weights = weights.to_java(:Integer)
+
+      # // set some basic pool settings
+      # // 5 initial, 5 min, and 250 max conns
+      # // and set the max idle time for a conn
+      # // to 6 hours
+      @pool.initConn = opts[:pool_initial_size]
+      @pool.minConn = opts[:pool_min_size]
+      @pool.maxConn = opts[:pool_max_size]
+      @pool.maxIdle = opts[:pool_max_idle]
+
+      # // set the sleep for the maint thread
+      # // it will wake up every x seconds and
+      # // maintain the pool size
+      @pool.maintSleep = opts[:pool_maintenance_thread_sleep]
+      #
+      # // set some TCP settings
+      # // disable nagle
+      # // set the read timeout to 3 secs
+      # // and don't set a connect timeout
+      @pool.nagle = opts[:pool_use_nagle]
+      @pool.socketTO = opts[:pool_socket_timeout]
+      @pool.socketConnectTO = opts[:pool_socket_connect_timeout]
+      @pool.aliveCheck = true
+      @pool.initialize__method
+    end
+  end
+
+  def reset
+    @pool.shut_down
+    @pool.initialize__method
+  end
+
+  ##
+  # Returns the servers that the client has been configured to
+  # use. Injects an alive? method into the string so it works with the
+  # updated Rails MemCacheStore session store class.
+  def servers
+    @pool.servers.to_a.collect do |s|
+      s.instance_eval(<<-EOIE)
+      def alive?
+        #{!!stats[s]}
+      end
+      EOIE
+      s
+    end rescue []
+  end
+
+  ##
+  # Determines whether any of the connections to the servers is
+  # alive. We are alive if it is the case.
+  def alive?
+    servers.to_a.any? { |s| s.alive? }
+  end
+
+  alias :active? :alive?
+
+  ##
+  # Retrieves a value associated with the key from the
+  # cache. Retrieves the raw value if the raw parameter is set.
+  def get(key, raw = false)
+    value = @client.get(make_cache_key(key))
+    return nil if value.nil?
+    unless raw
+      marshal_bytes = java.lang.String.new(value).getBytes(MARSHALLING_CHARSET)
+      value = Marshal.load(String.from_java_bytes(marshal_bytes))
+    end
+    value
+  end
+
+  alias :[] :get
+
+  ##
+  # Retrieves the values associated with the keys parameter.
+  def get_multi(keys, raw = false)
+    keys = keys.map {|k| make_cache_key(k)}
+    keys = keys.to_java :String
+    values = {}
+    values_j = @client.getMulti(keys)
+    values_j.to_a.each {|kv|
+      k,v = kv
+      next if v.nil?
+      unless raw
+        marshal_bytes = java.lang.String.new(v).getBytes(MARSHALLING_CHARSET)
+        v = Marshal.load(String.from_java_bytes(marshal_bytes))
+      end
+      values[k] = v
+    }
+    values
+  end
+
+  ##
+  # Associates a value with a key in the cache. MemCached will expire
+  # the value if an expiration is provided. The raw parameter allows
+  # us to store a value without marshalling it first.
+  def set(key, value, expiry = 0, raw = false)
+    raise MemCacheError, "Update of readonly cache" if @readonly
+    value = marshal_value(value) unless raw
+    key = make_cache_key(key)
+    if expiry == 0
+      @client.set key, value
+    else
+      @client.set key, value, expiration(expiry)
+    end
+  end
+
+  alias :[]= :set
+
+  ##
+  # Add a new value to the cache following the same conventions that
+  # are used in the set method.
+  def add(key, value, expiry = 0, raw = false)
+    raise MemCacheError, "Update of readonly cache" if @readonly
+    value = marshal_value(value) unless raw
+    if expiry == 0
+      @client.add make_cache_key(key), value
+    else
+      @client.add make_cache_key(key), value, expiration(expiry)
+    end
+  end
+
+  ##
+  # Removes the value associated with the key from the cache. This
+  # will ignore values that are not already present in the cache,
+  # which makes this safe to use without first checking for the
+  # existance of the key in the cache first.
+  def delete(key, expires = 0)
+    raise MemCacheError, "Update of readonly cache" if @readonly
+    @client.delete(make_cache_key(key))
+  end
+
+  ##
+  # Replaces the value associated with a key in the cache if it
+  # already is stored. It will not add the value to the cache if it
+  # isn't already present.
+  def replace(key, value, expiry = 0, raw = false)
+    raise MemCacheError, "Update of readonly cache" if @readonly
+    value = marshal_value(value) unless raw
+    if expiry == 0
+      @client.replace make_cache_key(key), value
+    else
+      @client.replace make_cache_key(key), value
+    end
+  end
+
+  ##
+  # Increments the value associated with the key by a certain amount.
+  def incr(key, amount = 1)
+    raise MemCacheError, "Update of readonly cache" if @readonly
+    value = get(key) || 0
+    value += amount
+    set key, value
+    value
+  end
+
+  ##
+  # Decrements the value associated with the key by a certain amount.
+  def decr(key, amount = 1)
+    raise MemCacheError, "Update of readonly cache" if @readonly
+    value = get(key) || 0
+    value -= amount
+    set key, value
+    value
+  end
+
+  ##
+  # Clears the cache.
+  def flush_all
+    @client.flush_all
+  end
+
+  ##
+  # Reports statistics on the cache.
+  def stats
+    stats_hash = {}
+    @client.stats.each do |server, stats|
+      stats_hash[server] = Hash.new
+      stats.each do |key, value|
+        unless key == 'version'
+          value = value.to_f
+          value = value.to_i if value == value.ceil
+        end
+        stats_hash[server][key] = value
+      end
+    end
+    stats_hash
+  end
+
+  class MemCacheError < RuntimeError; end
+
+  protected
+  def make_cache_key(key)
+    if namespace.nil? then
+      key
+    else
+      "#{@namespace}:#{key}"
+    end
+  end
+
+  def expiration(expiry)
+    java.util.Date.new((Time.now.to_i + expiry) * 1000)
+  end
+
+  def marshal_value(value)
+    marshal_bytes = Marshal.dump(value).to_java_bytes
+    java.lang.String.new(marshal_bytes, MARSHALLING_CHARSET)
+  end
+end
+

data/spec/jruby_memcache_spec.rb

@@ -0,0 +1,243 @@
+require 'java'
+require File.dirname(__FILE__) + '/../lib/memcache'
+
+describe MemCache do
+  before(:all) do
+    @server = "127.0.0.1:11211"
+    @client = MemCache.new @server
+    @client.flush_all
+  end
+
+  after(:each) do
+    @client.flush_all
+  end
+
+  it "should return nil for a non-existent key" do
+    @client.get('non-existent-key').should be_nil
+  end
+
+  describe "setting servers" do
+    it "should work if the instance is created with a single String argument" do
+      @client = MemCache.new @server
+      @client.servers.should == [@server]
+    end
+
+    it "should work if the instance is created with an Array" do
+      @client = MemCache.new [ @server ]
+      @client.servers.should == [ @server ]
+    end
+
+    it "should work if the instance is created with a Hash" do
+      @client = MemCache.new [ @server ], :namespace => 'test'
+      @client.servers.should == [ @server ]
+    end
+
+    it "should work with an explicit pool name" do
+      @client = MemCache.new([@server], :pool_name => 'new_pool')
+      @client.pool_name.should == 'new_pool'
+    end
+  end
+
+  describe "namespacing" do
+    before(:each) do
+      @ns = 'namespace'
+      @nsclient = MemCache.new [ @server ] , :namespace => @ns
+      @nsclient.flush_all
+      @nsclient.set "test", 333, 0
+    end
+
+    it "should set and get values transparently" do
+      @nsclient.get("test").to_i.should == 333
+    end
+
+    it "should set values to the given namespace" do
+      @client.get("#{@ns}:test").to_i.should == 333
+    end
+
+    it "should not set a value without the given namespace" do
+      @client.get("test").to_i.should_not == 333
+    end
+
+    it "should delete values in the given namespace" do
+      @nsclient.delete "test"
+      @nsclient.get("test").should be_nil
+    end
+
+    it "should increment in the given namespace" do
+      @nsclient.incr("test").to_i.should == 334
+    end
+
+    it "should decrement values in the given namespace" do
+      @nsclient.decr("test").should == 332
+    end
+  end
+
+  describe "after setting a value to MemCache" do
+    before(:each) do
+      @client.set 'key', 'value'
+    end
+
+    it "should be able to retrieve the value" do
+      @client.get('key').should == 'value'
+    end
+
+    it "should not be able to retrieve the value after deleting" do
+      @client.delete('key')
+      @client.get('key').should be_nil
+    end
+
+    it "should not be able to retrieve the value after flushing everything" do
+      @client.flush_all
+      @client.get("key").should be_nil
+    end
+
+    it "should work exactly the same if the []= operator were used" do
+      @client['key'] = 'val'
+      @client.get('key').should == 'val'
+    end
+  end
+
+  describe "replacing values from the cache." do
+    before :each do
+      @client['key'] = 'value'
+    end
+
+    it "should be able to replace the stored value." do
+      @client.replace('key', 'new value').should be_true
+      @client['key'].should == 'new value'
+    end
+
+    it "should not replace values that are not in the cache." do
+      @client.replace('notthere', 'value').should be_false
+    end
+  end
+
+  describe "using the Hash notation" do
+    before :each do
+      @client['key'] = 'value'
+    end
+
+    it "should be able to retrieve the value using []" do
+      @client['key'].should == 'value'
+    end
+
+    it "should be able to retrieve the value using get" do
+      @client.get('key').should == 'value'
+    end
+  end
+
+  describe "#stats" do
+    it "should return a hash" do
+      @client.stats.should be_instance_of(Hash)
+    end
+
+    # it "should return 0 for curr_items" do
+    #   @client.stats[@server]['curr_items'].should == 0
+    # end
+
+    it "should return a float for rusage_system and rusage_user" do
+      @client.stats[@server]['rusage_system'].should be_instance_of(Float)
+      @client.stats[@server]['rusage_user'].should be_instance_of(Float)
+    end
+
+    it "should return a String for version" do
+      @client.stats[@server]['version'].should be_instance_of(String)
+    end
+
+  end
+
+  describe "#incr" do
+
+    it "should increment a value by 1 without a second parameter" do
+      @client.set 'incr', 100, 0
+      @client.incr 'incr'
+      @client.get('incr').to_i.should == 101
+    end
+
+    it "should increment a value by a given second parameter" do
+      @client.set 'incr', 100, 0
+      @client.incr 'incr', 20
+      @client.get('incr').to_i.should == 120
+    end
+  end
+
+  describe "#decr" do
+
+    it "should decrement a value by 1 without a second parameter" do
+      @client.set 'decr', 100, 0
+      @client.decr 'decr'
+      @client.get('decr').to_i.should == 99
+    end
+
+    it "should decrement a value by a given second parameter" do
+      @client.set 'decr', 100, 0
+      @client.decr 'decr', 20
+      @client.get('decr').to_i.should == 80
+    end
+  end
+
+  describe "with Ruby Objects" do
+    it "should be able to transparently set and get equivalent Ruby objects" do
+      obj = { :test => :hi }
+      @client.set('obj', obj)
+      @client.get('obj').should == obj
+    end
+  end
+
+  describe "using set with an expiration" do
+    it "should make a value unretrievable if the expiry is set to a negative value" do
+      @client.set('key', 'val', -1)
+      @client.get('key').should be_nil
+    end
+
+    it "should make a value retrievable for only the amount of time if a value is given" do
+      @client.set('key', 'val', 2)
+      @client.get('key').should == 'val'
+      sleep(3)
+      @client.get('key').should be_nil
+    end
+  end
+
+  describe "#get_multi" do
+    it "should get 2 keys" do
+      @client.set('key', 'val')
+      @client.set('key2', 'val2')
+      @client.get_multi(%w/key key2/).should == {'key' => 'val', 'key2' => 'val2'}
+    end
+
+    it "should ignore nil values" do
+      @client.set('key', 'val')
+      @client.set('key2', 'val2')
+      @client.get_multi(%w/key key2 key3/).should == {'key' => 'val', 'key2' => 'val2'}
+    end
+
+    it "should not marshall if requested" do
+      @client.set('key', 'val', 0, true)
+      @client.set('key2', 'val2', 0, true)
+      @client.get_multi(%w/key key2/, true).should == {'key' => 'val', 'key2' => 'val2'}
+    end
+  end
+
+  describe "aliveness of the MemCache server." do
+    before :each do
+      @servers = ["localhost:11211", "localhost:11212", {:pool_name => "test"}]
+      @client = MemCache.new @servers
+      @client.flush_all
+    end
+
+    it "should report the client as being alive." do
+      @client.should be_alive
+    end
+
+    it "should report localhost:11211 as being alive." do
+      servers = @client.servers
+      servers.first.should be_alive
+    end
+
+    it "should report localhost:11212 as not being alive." do
+      servers = @client.servers
+      servers.find {|s| s.to_s == "localhost:11212"}.should be_nil
+    end
+  end
+end
+

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: jruby-memcache-client
+version: !ruby/object:Gem::Version 
+  version: 1.6.0
+platform: ruby
+authors: 
+- Abhi Yerra
+- Ikai Lan
+- Frederic Jean
+- Lennon Day-Reynolds
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-20 00:00:00 -06:00
+default_executable: 
+dependencies: []
+
+description: A drop in replacement for Ruby's memcache-client.
+email: abhi@traytwo.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- .gitignore
+- MIT-LICENSE
+- README
+- Rakefile
+- VERSION.yml
+- jruby-memcache-client.gemspec
+- lib/java/java_memcached-release_2.0.1.jar
+- lib/memcache.rb
+- spec/jruby_memcache_spec.rb
+has_rdoc: true
+homepage: http://github.com/ikai/jruby-memcache-client
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.4
+signing_key: 
+specification_version: 2
+summary: A drop in replacement for Ruby's memcache-client.
+test_files: 
+- spec/jruby_memcache_spec.rb