hybrid_memcache 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Matthew Knopp
+
+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.rdoc

@@ -0,0 +1,17 @@
+= hybrid-memcache
+
+ninjudd-memcache compatible interface on top of fauna-memcached
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Matthew Knopp. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name        = "hybrid_memcache"
+    gem.summary     = %Q{ninjudd-memcached compatible interface to fauna-memcached}
+    gem.description = %Q{the summary says it all.}
+    gem.email       = "mknopp@yammer-inc.com"
+    gem.homepage    = "http://github.com/mhat/hybrid_memcache"
+    gem.authors     = ["Matthew Knopp"]
+
+    gem.add_dependency "memcached", ">= 0.18.0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "hybrid_memcache #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/hybrid_memcache.gemspec

@@ -0,0 +1,58 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{hybrid_memcache}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Matthew Knopp"]
+  s.date = %q{2010-02-17}
+  s.description = %q{the summary says it all.}
+  s.email = %q{mknopp@yammer-inc.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "hybrid_memcache.gemspec",
+     "lib/hybrid_memcache.rb",
+     "test/helper.rb",
+     "test/memcache_test.rb",
+     "test/test_helper.rb",
+     "test/test_hybrid_memcache.rb"
+  ]
+  s.homepage = %q{http://github.com/mhat/hybrid_memcache}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{ninjudd-memcached compatible interface to fauna-memcached}
+  s.test_files = [
+    "test/helper.rb",
+     "test/memcache_test.rb",
+     "test/test_helper.rb",
+     "test/test_hybrid_memcache.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<memcached>, [">= 0.18.0"])
+    else
+      s.add_dependency(%q<memcached>, [">= 0.18.0"])
+    end
+  else
+    s.add_dependency(%q<memcached>, [">= 0.18.0"])
+  end
+end
+

data/lib/hybrid_memcache.rb

@@ -0,0 +1,362 @@
+require 'memcached'
+
+class Memcache < Memcached
+  WRITE_LOCK_WAIT = 1
+  LOCK_TIMEOUT    = 5
+  
+  def initialize (opts={})
+    servers    = opts[:servers] && opts.delete(:servers)
+    @namespace = ""
+    
+    super(servers, {
+      :prefix_key           =>  '',
+      :prefix_delimiter     =>  '',
+      :support_cas          => true,
+      
+      :hash                 => :fnv1_32,
+      :distribution         => :consistent_ketama,
+      :ketama_weighted      => true,
+      :server_failure_limit => 2,
+      :retry_timeout        => 30,
+      
+      :default_ttl          => 604800,
+    }.merge!(opts))
+  end
+
+
+  def clone
+     klone = self.class.new({ :servers => servers }.merge(options))
+     klone.set_namespace @namespace
+     klone
+  end
+
+
+  def add(key, value, opts={})
+    super(normalize_keys(key), value, *opts_to_params(opts))
+    return value
+  rescue Memcached::NotStored
+    return nil
+  end
+
+  
+  def inspect
+    "<Memcache: %d servers, ns: %p" % [ servers.length, namespace ]
+  end
+
+
+  def in_namespace(ns)
+    # Temporarily change the namespace for convenience.
+    begin
+      old_namespace = @namespace
+      self.set_namespace("#{old_namespace}#{ns}")
+      yield
+    ensure
+      self.set_namespace(old_namespace)
+    end
+  end
+
+
+  def namespace 
+    @namespace
+  end
+
+  
+  def set_namespace(ns)
+    @namespace = ns
+  end
+  alias     namespace= set_namespace
+  alias set_namespace= set_namespace
+
+
+  def get(keys, opts={})
+    marshal = !opts[:raw]
+    cas     =  opts[:cas]
+    
+    unless keys.is_a?(Array)
+      ## ninjudd-memcache has a weird behaviour where get can be called with an
+      ## expiry and that will transform the get into get+cas. this in turn has
+      ## the effect of extending the expiry of the object. 
+      if opts[:expiry]
+        value = get(keys,        :cas => true)
+        value = cas(keys, value, :cas => value.memcache_cas, :expiry => opts[:expiry])
+        return value
+      end
+      
+      ## Single get
+      value, flags, ret = Lib.memcached_get_rvalue(@struct, normalize_keys(keys))
+      
+      ## ninjudd-memcache treats broken servers as cache missis, so return nil
+      check_return_code(ret, keys)
+      return nil unless ret == 0
+      
+      if marshal
+        value = Marshal.load(value) 
+      end
+
+      value.memcache_cas   = cas ? @struct.result.cas : false
+      value.memcache_flags = flags
+      return value
+    else
+      ## Multi get
+      return {} if keys.empty?
+
+      ## ninjudd-memcache normalizes keys into the form namespace:index:key
+      ## but it hides this form from the caller, so the caller expects to 
+      ## get a hash with the keys in their denormalized form. That's what
+      ## the norm_to_std hash is all about. 
+      normalized  = normalize_keys(keys)
+      norm_to_std = {}
+      
+      ## but note, the keys have to be transformed into strings, even if they
+      ## started out as fixnums
+      keys.each_with_index {|k,idx| norm_to_std[normalized[idx]] = keys[idx].to_s }
+      
+      ret = Lib.memcached_mget(@struct, normalized)
+      
+      ## once again: potentiall braken server == cache miss
+      check_return_code(ret, normalized)
+      return {} unless ret == 0
+    
+      hash = {}
+      keys.each do
+        value, key, flags, ret = Lib.memcached_fetch_rvalue(@struct)
+        if ret == Lib::MEMCACHED_END
+          break 
+        end
+        check_return_code(ret, key)
+        
+        # Assign the value
+        if marshal
+          value = Marshal.load(value) 
+        end 
+        value.memcache_cas   = cas ? @struct.result.cas : false
+        value.memcache_flags = flags
+        
+        hash[ norm_to_std[key] ] = value
+      end
+      return hash
+    end
+  rescue Memcached::NotFound
+    return nil
+  end
+
+
+  def read(keys, opts={})
+    get(keys, opts.merge(:raw => true))
+  end
+
+
+  def set(key, value, opts={})
+    super(normalize_keys(key), value, *opts_to_params(opts))
+    return value
+  rescue Memcache::NotFound
+    return nil
+  end
+
+
+  def write(key, value, opts={})
+    set(key, value, opts.merge(:raw => true))
+  end
+
+
+  def replace(key, value, opts={})
+    super(normalize_keys(key), value, *opts_to_params(opts))
+    return value
+  rescue Memcache::NotStored
+    return nil
+  end
+
+
+  def cas(key, value, opts={})
+    ttl, marshal, flags = opts_to_params(opts)
+    key  = normalize_keys(key)
+    data = marshal ? Marshal.dump(value) : value
+
+    check_return_code(Lib.memcached_cas(@struct, key, data, ttl, flags, opts[:cas]), key)
+    value.memcache_cas   = @struct.result.cas
+    value.memcache_flags = @struct.result.flags
+    return value
+  rescue Memcache::NotStored
+   return nil
+  end
+
+
+  def prepend(key,value)
+    super(normalize_keys(key), value)
+    return true
+  rescue Memcache::NotStored
+    return false
+  end
+
+
+  def append(key, value)
+    super(normalize_keys(key), value)
+    return true
+  rescue Memcache::NotStored
+    return false
+  end
+
+
+  def count(key)
+    get(key, :raw => true).to_i
+  end
+
+
+  def increment(key, amount=1)
+    super(normalize_keys(key), amount)
+  rescue Memcache::NotStored
+    return nil
+  end
+  alias incr increment
+
+
+  def decrement(key, amount=1)
+    super(normalize_keys(key), amount)
+  rescue Memcache::NotStored
+    return nil
+  end
+  alias decr decrement
+
+
+  def update(key, opts={})
+    if value = get(key, :cas => true)
+      cas(key, yield(value), opts.merge!(:cas => value.memcache_cas))
+    else
+      add(key, yield(value), opts)
+    end
+  end
+
+
+  def get_or_add(key, *args)
+    if block_given?
+      opts = args[0] || {}
+      get(key) || add(key, yield,   opts) || get(key)
+    else
+      opts = args[1] || {}
+      get(key) || add(key, args[0], opts) || get(key)
+    end
+  end
+
+
+  def get_or_set(key, *args)
+    if block_given?
+      opts = args[0] || {}
+      get(key) || set(key, yield,   opts) || get(key)
+    else
+      opts = args[1] || {}
+      get(key) || set(key, args[0], opts) || get(key)
+    end
+  end
+
+
+  def get_some(keys, opts = {})
+    keys    = keys.collect { |k| k.to_s }
+    records = opts[:disable] ? {} : self.get(keys, opts)
+    
+    if opts[:validation]
+      records.delete_if do |key, value|
+        not opts[:validation].call(key, value)
+      end
+    end
+    
+    keys_to_fetch = keys - records.keys
+    method        = opts[:overwrite] ? :set : :add
+    if keys_to_fetch.any?
+      yield(keys_to_fetch).each do |key, value|
+        self.send(method, key, value, opts) unless opts[:disable] or opts[:disable_write]
+        records[key] = value
+      end
+    end
+    records
+  end
+
+
+  def lock_key(key)
+    "lock:#{key}"
+  end
+
+
+  def lock(key, opts={})
+    expiry = opts[:expiry] || LOCK_TIMEOUT
+    add(lock_key(key), Socket.gethostname, :expiry => expiry, :raw => true)
+  end
+
+
+  def unlock(key)
+    delete(lock_key(key))
+  end
+
+
+  def with_lock(key, opts={})
+    until lock(key) do
+      return if opts[:ignore]
+      sleep(WRITE_LOCK_WAIT)
+    end
+    yield
+    unlock(key) unless opts[:keep]
+  end
+
+
+  def locked?(key)
+    get(lock_key(key), :raw => true)
+  end
+
+
+  def delete(key)
+    super(normalize_keys(key))
+    return true
+  rescue Memcached::NotFound
+    return false
+  end
+
+
+  def flush_all(opts={})
+    flush
+  end
+  alias clear flush_all
+
+
+  def [](key)
+    get(key)
+  end
+
+
+  def []=(key,value)
+    set(key,value)
+  end
+
+
+  def normalize_keys (keys)
+    ns = @namespace.nil? || @namespace.size == 0 ? "" : "#{@namespace}:"
+    
+    unless keys.is_a?(Array) 
+      k = "#{ns}#{keys}"
+      k.gsub!(/%/, '%%') if k.include?('%')
+      k.gsub!(/ /, '%s') if k.include?(' ')
+      return k
+    else
+      return keys.collect do |k| 
+        k = "#{ns}#{k}" 
+        k.gsub!(/%/, '%%') if k.include?('%')
+        k.gsub!(/ /, '%s') if k.include?(' ')
+        k
+      end
+    end
+  end
+
+
+  def opts_to_params (opts={})
+    ## - if no :expiry, use @default_ttl
+    ## - fauna-memcached uses marshal which has the opposite meaning of 
+    ##   ninjudd's :raw. that is, :raw means DO NOT marshal, so invert
+    ##   :raw via ! ... 
+    ## - if no :flags,  use FLAGS
+    return  opts[:expiry] || @default_ttl,
+           !opts[:raw],
+            opts[:flags]  || FLAGS
+  end
+end
+
+class Object
+  attr_accessor :memcache_flags, :memcache_cas
+end

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'hybrid_memcache'
+
+class Test::Unit::TestCase
+end

data/test/memcache_test.rb

@@ -0,0 +1,233 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/test_helper'
+
+class MemcacheTest < Test::Unit::TestCase
+  PORTS = [11212, 11213, 11214, 11215, 11216, 11217]
+
+  def m
+    @memcache
+  end
+
+  def setup
+    start_memcache(*PORTS)
+    @memcache = Memcache.new(:servers => PORTS.collect {|p| "localhost:#{p}"})
+  end
+    
+  def teardown
+    stop_memcache(*PORTS)
+  end
+
+  def test_get_and_set    
+    100.times do |i|
+      m.set(i.to_s, i)
+      assert_equal i, m.get(i.to_s)
+    end
+
+    keys = (0..200).to_a
+    results = m.get(keys)
+    assert_equal 100, results.size
+    results.each do |key, value|
+      assert_equal key.to_i, value
+    end
+    
+    100.times do |i|
+      m.set(i.to_s, i.to_s, :raw => true)
+      assert_equal i.to_s, m.get(i.to_s, :raw => true)
+    end
+
+    results = m.get(keys ,:raw => true)
+    assert_equal 100, results.size
+    results.each do |key, value|
+      assert_equal key, value
+    end
+  end
+
+  def test_alternate_accessors
+    m['baz'] = 24
+    assert_equal 24, m['baz']
+  end
+
+  def test_add_and_replace
+    100.times do |i|
+      m.replace(i.to_s, [:foo, i])
+      assert_equal nil, m.get(i.to_s)
+
+      m.add(i.to_s, [:bar, i])
+      assert_equal [:bar, i], m.get(i.to_s)
+
+      m.replace(i.to_s, [:foo, i])
+      assert_equal [:foo, i], m.get(i.to_s)
+
+      m.add(i.to_s, [:baz, i])
+      assert_equal [:foo, i], m.get(i.to_s)
+
+      m.replace(i.to_s, 'blah', :raw => true)
+      assert_equal 'blah', m.get(i.to_s, :raw => true)
+
+      m.delete(i.to_s)
+      assert_equal nil, m.get(i.to_s, :raw => true)
+
+      m.add(i.to_s, 'homerun', :raw => true)
+      assert_equal 'homerun', m.get(i.to_s, :raw => true)      
+    end
+  end
+
+  def test_append_and_prepend
+    100.times do |i|
+      m.append(i.to_s, 'doh!')
+      assert_equal nil, m.read(i.to_s)
+
+      m.write(i.to_s, 'bar')
+      m.prepend(i.to_s, 'foo')
+      assert_equal 'foobar', m.read(i.to_s)
+
+      m.append(i.to_s, i.to_s)
+      assert_equal "foobar#{i}", m.read(i.to_s)
+    end
+  end
+
+  def test_get_or_set
+    100.times do |i|
+      m.get_or_set("foo#{i}", [i, :foo])
+      assert_equal [i, :foo], m["foo#{i}"]
+
+      m.get_or_set("foo#{i}") {raise}
+      assert_equal [i, :foo], m["foo#{i}"]    
+
+      # Overwrite if changed.
+      m.get_or_set("bar#{i}") do
+        m.set("bar#{i}", [i, :foo])
+        [i, :bar]
+      end
+      assert_equal [i, :bar], m["bar#{i}"]
+    end
+  end
+
+  def test_get_or_add
+    100.times do |i|
+      m.get_or_add("foo#{i}", [:foo, i])
+      assert_equal [:foo, i], m["foo#{i}"]
+
+      m.get_or_add("foo#{i}") {raise}
+      assert_equal [:foo, i], m["foo#{i}"]    
+
+      # Don't overwrite if changed.
+      m.get_or_add("bar#{i}") do
+        m.set("bar#{i}", [:foo, i])
+        :bar
+      end
+      assert_equal [:foo, i], m["bar#{i}"]
+    end
+  end
+
+  def test_update
+    100.times do |i|
+      m.set("foo#{i}", [:foo, i])
+      assert_equal [:foo, i], m["foo#{i}"]
+
+      m.update("foo#{i}") do |list|
+        list << i.to_s
+        list << :bar
+        list
+      end
+      assert_equal [:foo, i, i.to_s, :bar], m["foo#{i}"]
+    end
+  end
+
+  def test_get_some
+    100.times do |i|
+      i = i * 2
+      m.set(i.to_s, i)
+      assert_equal i, m.get(i.to_s)
+    end
+
+    keys = (0...200).to_a
+    results = m.get_some(keys) do |missing_keys|
+      assert_equal 100, missing_keys.size
+      r = {}
+      missing_keys.each do |key|
+        r[key] = key.to_i
+      end
+      r
+    end
+
+    assert_equal 200, results.size
+    results.each do |key, value|
+      assert_equal key.to_i, value
+    end
+  end
+
+  def test_get_with_reset_expiry
+    m.add('foo', 'quick brown fox', :expiry => 1)
+    assert_equal 'quick brown fox', m.get('foo', :expiry => 2)
+    sleep(1)    
+    assert_equal 'quick brown fox', m.get('foo')
+  end
+
+  def test_expiry
+    100.times do |i|
+      m.set("int#{i}", i, :expiry => 1)
+      assert_equal i, m.get("int#{i}")
+
+      m.set("time#{i}", i, :expiry => Time.now + 1)
+      assert_equal i, m.get("time#{i}")
+    end
+
+    sleep 2
+
+    100.times do |i|
+      assert_equal nil, m.get("int#{i}")
+      assert_equal nil, m.get("time#{i}")
+    end
+  end
+
+  def test_in_namespace
+    threads = []
+    10.times do |i|
+      m.in_namespace("_#{i}_") do
+        10.times do |j|
+          m.in_namespace("_#{j}_") do
+            assert_equal nil, m.get('foo')
+            m.set('foo', 'bar')
+            assert_equal 'bar', m.get('foo')
+          end
+        end
+      end
+    end
+  end
+
+  def test_incr_and_decr
+    m.write('foo', 0)
+
+    m.incr('foo', 100)
+    assert_equal 100, m.count('foo')
+
+    m.decr('foo', 100)
+    assert_equal 0, m.count('foo')
+
+    m.incr('foo', 500)
+    assert_equal 500, m.count('foo')
+
+    m.decr('foo', 300)
+    assert_equal 200, m.count('foo')
+
+    m.decr('foo', 300)
+    assert_equal 0, m.count('foo')
+  end
+
+  def test_flags
+    m.set('foo', :foo, :flags => 43)
+    assert_equal 43, m.get('foo').memcache_flags
+
+    m.set('foo', 'foo', :raw => true, :flags => 43)
+    assert_equal 43, m.get('foo', :raw => true).memcache_flags
+  end
+
+  def test_clone
+    m.set('foo', 1)
+    c = m.clone
+
+    #assert_not_equal m.servers.collect {|s| s.send(:socket)},
+    #                 c.servers.collect {|s| s.send(:socket)}
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,22 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+require 'rubygems'
+require 'hybrid_memcache'
+
+system 'killall memcached 2> /dev/null'
+
+class Test::Unit::TestCase
+  def start_memcache(*ports)
+    ports.each do |port|
+      system("memcached -p #{port} -U 0 -d -P /tmp/memcached_#{port}.pid")
+    end
+    sleep 0.1
+  end
+
+  def stop_memcache(*ports)
+    ports.each do |port|
+      pid = File.read("/tmp/memcached_#{port}.pid").to_i
+      Process.kill('TERM', pid)
+    end
+  end
+end
+

data/test/test_hybrid_memcache.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestFaunaNinjuddHybridMemcache < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: hybrid_memcache
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Matthew Knopp
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-17 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: memcached
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.18.0
+    version: 
+description: the summary says it all.
+email: mknopp@yammer-inc.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- hybrid_memcache.gemspec
+- lib/hybrid_memcache.rb
+- test/helper.rb
+- test/memcache_test.rb
+- test/test_helper.rb
+- test/test_hybrid_memcache.rb
+has_rdoc: true
+homepage: http://github.com/mhat/hybrid_memcache
+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.5
+signing_key: 
+specification_version: 3
+summary: ninjudd-memcached compatible interface to fauna-memcached
+test_files: 
+- test/helper.rb
+- test/memcache_test.rb
+- test/test_helper.rb
+- test/test_hybrid_memcache.rb