dkastner-moneta 0.7.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Yehuda Katz
+
+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,56 @@
+Moneta: A unified interface for key/value stores
+================================================
+
+Moneta provides a standard interface for interacting with various kinds of key/value stores.
+
+Out of the box, it supports:
+
+* File store for xattr
+* Basic File Store
+* Memcache store
+* In-memory store
+* The xattrs in a file system
+* DataMapper
+* S3
+* Berkeley DB
+* Redis
+* SDBM
+* Tokyo
+* CouchDB
+
+All stores support key expiration, but only memcache supports it natively. All other stores
+emulate expiration.
+
+The Moneta API is purposely extremely similar to the Hash API. In order so support an
+identical API across stores, it does not support iteration or partial matches, but that
+might come in a future release.
+
+The API:
+
+#initialize(options)::          options differs per-store, and is used to set up the store
+
+#[](key)::                      retrieve a key. if the key is not available, return nil
+
+#fetch(key, &block)::           retrieve a key. if the key is not available, execute the
+                                block and return its return value.
+
+#fetch(key, value)              retrieve a key. if the key is not available, return the value
+
+#[]=(key, value)::              set a value for a key. if the key is already used, clobber it.
+                                keys set using []= will never expire
+
+#delete(key)::                  delete the key from the store and return the current value
+
+#key?(key)::                    true if the key exists, false if it does not
+
+#has_key?(key)::                alias for key?
+
+#store(key, value, options)::   same as []=, but you can supply an :expires_in option,
+                                which will specify a number of seconds before the key
+                                should expire. In order to support the same features
+                                across all stores, only full seconds are supported
+
+#update_key(key, options)::     updates an existing key with a new :expires_in option.
+                                if the key has already expired, it will not be updated.
+
+#clear::                        clear all keys in this store

data/Rakefile

@@ -0,0 +1,60 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'spec/rake/spectask'
+require 'date'
+
+GEM = "moneta"
+GEM_VERSION = "0.5.0"
+AUTHOR = "Yehuda Katz"
+EMAIL = "wycats@gmail.com"
+HOMEPAGE = "http://www.yehudakatz.com"
+SUMMARY = "A unified interface to key/value stores"
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  
+  # Uncomment this to add a dependency
+  # s.add_dependency "foo"
+  
+  s.require_path = 'lib'
+  s.autorequire = GEM
+  s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,specs}/**/*")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the gem locally"
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{GEM}-#{GEM_VERSION}}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{GEM}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+
+desc "Run all examples (or a specific spec with TASK=xxxx)"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_opts  = ["-cfs"]
+  t.spec_files = begin
+    if ENV["TASK"] 
+      ENV["TASK"].split(',').map { |task| "spec/**/#{task}_spec.rb" }
+    else
+      FileList['spec/**/*_spec.rb']
+    end
+  end
+end

data/TODO

@@ -0,0 +1,4 @@
+TODO:
+Fix LICENSE with your name
+Fix Rakefile with your name and contact info
+Add your code to lib/<%= name %>.rb

data/lib/moneta/adapters/basic_file.rb

@@ -0,0 +1,84 @@
+#
+#  Basic File Store
+#  by Hampton Catlin
+#
+#  This cache simply uses a directory that it creates
+#  and manages to keep your file stores.
+#
+#  Specify :skip_expires => true if you aren't using
+#  expiration as this will slightly decrease your file size
+#  and memory footprint of the library
+#
+#  You can optionally also specify a :namespace
+#  option that will create a subfolder.
+#
+
+
+require 'fileutils'
+require "moneta"
+
+module Moneta
+  module Adapters
+    class BasicFile
+      include Moneta::Defaults
+
+      def initialize(options = {})
+        @namespace = options[:namespace]
+        @directory = ::File.join(options[:path], @namespace.to_s)
+
+        ensure_directory_created(@directory)
+      end
+
+      def key?(key, *)
+        !self[key].nil?
+      end
+
+      def [](key)
+        if ::File.exist?(path(key))
+          raw_get(key)
+        end
+      end
+
+      def store(key, value, *)
+        ensure_directory_created(::File.dirname(path(key)))
+        ::File.open(path(key), "w") do |file|
+          file.puts(serialize(value))
+        end
+      end
+
+      def delete(key, *)
+        value = self[key]
+        delete!(key)
+        value
+      end
+
+      def clear(*)
+        FileUtils.rm_rf(@directory)
+        FileUtils.mkdir(@directory)
+      end
+
+    private
+      def path(key)
+        ::File.join(@directory, key_for(key))
+      end
+
+      def raw_get(key)
+        deserialize(::File.read(path(key)))
+      end
+
+      def delete!(key)
+        FileUtils.rm(path(key))
+        nil
+      rescue Errno::ENOENT
+      end
+
+      def ensure_directory_created(directory_path)
+        if ::File.file?(directory_path)
+          raise StandardError, "The path you supplied #{directory_path} is a file"
+        elsif !::File.exists?(directory_path)
+          FileUtils.mkdir_p(directory_path)
+        end
+      end
+    end
+  end
+end

data/lib/moneta/adapters/couch.rb

@@ -0,0 +1,51 @@
+begin
+  require "couchrest"
+rescue LoadError
+  puts "You need the couchrest gem to use the CouchDB store"
+  exit
+end
+
+module Moneta
+  module Adapters
+    class Couch
+      include Defaults
+
+      def initialize(options = {})
+        @db = ::CouchRest.database!(options[:db])
+      end
+
+      def key?(key, *)
+        !self[key_for(key)].nil?
+      rescue RestClient::ResourceNotFound
+        false
+      end
+
+      def [](key)
+        deserialize(@db.get(key_for(key))["data"])
+      rescue RestClient::ResourceNotFound
+        nil
+      end
+
+      def store(key, value, *)
+        @db.save_doc("_id" => key_for(key), :data => serialize(value))
+      rescue RestClient::RequestFailed
+        self[key_for(key)]
+      end
+
+      def delete(key, *)
+        value = @db.get(key_for(key))
+
+        if value
+          @db.delete_doc({"_id" => value["_id"], "_rev" => value["_rev"]}) if value
+          deserialize(value["data"])
+        end
+      rescue RestClient::ResourceNotFound
+        nil
+      end
+
+      def clear(*)
+        @db.recreate!
+      end
+    end
+  end
+end

data/lib/moneta/adapters/datamapper.rb

@@ -0,0 +1,76 @@
+begin
+  gem "dm-core", "~> 1.0.0"
+  gem "dm-migrations", "~> 1.0.0"
+  gem "dm-sqlite-adapter", "~> 1.0.0"
+  require "dm-core"
+  require "dm-migrations"
+rescue LoadError
+  puts "You need the dm-core gem in order to use the DataMapper moneta store"
+  exit
+end
+
+class MonetaHash
+  include DataMapper::Resource
+
+  property :the_key, String, :key => true
+  property :value, Object, :lazy => false
+
+  def self.value(key)
+    obj = self.get(key)
+    obj && obj.value
+  end
+end
+
+module Moneta
+  module Adapters
+    class DataMapper
+      include Moneta::Defaults
+
+      def initialize(options = {})
+        @repository = options.delete(:repository) || :moneta
+        ::DataMapper.setup(@repository, options[:setup])
+        MonetaHash.auto_upgrade!(@repository)
+        @hash = MonetaHash
+      end
+
+      def key?(key, *)
+        repository_context { !!@hash.get(key_for(key)) }
+      end
+
+      def [](key)
+        repository_context { @hash.value(key_for(key)) }
+      end
+
+      def store(key, value, *)
+        string_key = key_for(key)
+        repository_context {
+          obj = @hash.get(string_key)
+          if obj
+            obj.update(string_key, value)
+          else
+            @hash.create(:the_key => string_key, :value => value)
+          end
+        }
+      end
+
+      def delete(key, *)
+        string_key = key_for(key)
+
+        repository_context {
+          value = self[key]
+          @hash.all(:the_key => string_key).destroy!
+          value
+        }
+      end
+
+      def clear(*)
+        repository_context { @hash.all.destroy! }
+      end
+
+    private
+      def repository_context
+        repository(@repository) { yield }
+      end
+    end
+  end
+end

data/lib/moneta/adapters/file.rb

@@ -0,0 +1,52 @@
+require "fileutils"
+
+module Moneta
+  module Adapters
+    class File
+      include Moneta::Defaults
+
+      def initialize(options = {})
+        @directory = options[:path]
+        if ::File.file?(@directory)
+          raise StandardError, "The path you supplied #{@directory} is a file"
+        elsif !::File.exists?(@directory)
+          FileUtils.mkdir_p(@directory)
+        end
+      end
+
+      def key?(key, *)
+        ::File.exist?(path(key))
+      end
+
+      def [](key)
+        if ::File.exist?(path(key))
+          Marshal.load(::File.read(path(key)))
+        end
+      end
+
+      def store(key, value, *)
+        ::File.open(path(key), "w") do |file|
+          contents = Marshal.dump(value)
+          file.puts(contents)
+        end
+      end
+
+      def delete(key, *)
+        value = self[key]
+        FileUtils.rm(path(key))
+        value
+      rescue Errno::ENOENT
+      end
+
+      def clear(*)
+        FileUtils.rm_rf(@directory)
+        FileUtils.mkdir(@directory)
+      end
+
+    private
+      def path(key)
+        ::File.join(@directory, key_for(key))
+      end
+    end
+  end
+end

data/lib/moneta/adapters/fog.rb

@@ -0,0 +1,62 @@
+begin
+  require "fog"
+rescue LoadError
+  puts "You need the Fog gem to use the S3 moneta store"
+  exit
+end
+
+module Moneta
+  module Adapters
+    class Fog
+      include Moneta::Defaults
+
+      def initialize(options = {})
+        bucket = options.delete(:namespace)
+        s3 = options.delete(:cloud).new(options)
+        @directory = s3.directories.create(:key => bucket)
+      end
+
+      def key?(key)
+        !@directory.files.head(key_for(key)).nil?
+      end
+
+      def [](key)
+        if value = get(key)
+          deserialize(value.body)
+        end
+      end
+
+      def delete(key)
+        value = get(key)
+        if value
+          value.destroy
+          deserialize(value.body)
+        end
+      end
+
+      def store(key, value, options = {})
+        #perms = options[:perms]
+        #headers = options[:headers] || {}
+        @directory.files.create(:key => key_for(key), :body => serialize(value))
+      end
+
+      # def update_key(key, options = {})
+      #   debug "update_key(key=#{key}, options=#{options.inspect})"
+      #   k = s3_key(key, false)
+      #   k.save_meta(meta_headers_from_options(options)) unless k.nil?
+      # end
+
+      def clear
+        @directory.files.all.each do |file|
+          file.destroy
+        end
+        self
+      end
+
+    private
+      def get(key)
+        @directory.files.get(key_for(key))
+      end
+    end
+  end
+end

data/lib/moneta/adapters/lmc.rb

@@ -0,0 +1,40 @@
+begin
+  require "localmemcache"
+rescue LoadError
+  puts "You need the localmemcache gem to use the LMC moneta store"
+  exit
+end
+
+module Moneta
+  module Adapters
+    class LMC
+      include Defaults
+
+      def initialize(options = {})
+        @hash = LocalMemCache.new(:filename => options[:filename])
+      end
+
+      def [](key)
+        deserialize(@hash[key_for(key)])
+      end
+
+      def store(key, value, *) 
+        @hash[key_for(key)] = serialize(value)
+      end
+
+      def clear(*)
+        @hash.clear
+      end
+
+      def key?(key, *)
+        @hash.keys.include?(key_for(key))
+      end
+
+      def delete(key, *)
+        value = self[key]
+        @hash.delete(key_for(key))
+        value
+      end
+    end
+  end
+end

data/lib/moneta/adapters/memcache.rb

@@ -0,0 +1,49 @@
+begin
+  require "memcached"
+  MemCache = Memcached
+rescue LoadError
+  require "memcache"
+rescue
+  puts "You need either the `memcached` or `memcache-client` gem to use the Memcache moneta store"
+  exit
+end
+
+module Moneta
+  module Adapters
+    class Memcache
+      include Moneta::Defaults
+
+      def initialize(options = {})
+        @cache = ::MemCache.new(options.delete(:server), options)
+      end
+
+      def key?(key, *)
+        !self[key].nil?
+      end
+
+      def [](key)
+        deserialize(@cache.get(key_for(key)))
+      rescue MemCache::NotFound
+      end
+
+      def delete(key, *)
+        value = self[key]
+        @cache.delete(key_for(key)) if value
+        value
+      end
+
+      def store(key, value, *)
+        @cache.set(key_for(key), serialize(value))
+      end
+
+      def clear(*)
+        @cache.flush
+      end
+
+    private
+      def key_for(key)
+        [super].pack("m").strip
+      end
+    end
+  end
+end

data/lib/moneta/adapters/memory.rb

@@ -0,0 +1,23 @@
+module Moneta
+  module Adapters
+    class Memory < Hash
+      include Moneta::Defaults
+
+      def [](key)
+        deserialize(super(key_for(key)))
+      end
+
+      def key?(key, *)
+        super(key_for(key))
+      end
+
+      def store(key, value, *args)
+        super(key_for(key), serialize(value), *args)
+      end
+
+      def delete(key, *args)
+        deserialize(super(key_for(key), *args))
+      end
+    end
+  end
+end

data/lib/moneta/adapters/mongodb.rb

@@ -0,0 +1,64 @@
+begin
+  require "mongo"
+rescue LoadError
+  puts "You need the mongo gem to use the MongoDB moneta store"
+  exit
+end
+require 'uri'
+
+module Moneta
+  module Adapters
+    class MongoDB
+      include Moneta::Defaults
+
+      def initialize(options = {})
+        if options[:uri]
+          conn = Mongo::Connection.from_uri options[:uri]
+          db_name = URI.parse(options[:uri]).path.sub('/','')
+          db_name ||= options[:db]
+        else
+          options = {
+            :host => ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost',
+            :port => ENV['MONGO_RUBY_DRIVER_PORT'] || Mongo::Connection::DEFAULT_PORT,
+            :db => 'cache',
+            :collection => 'cache'
+          }.update(options)
+          conn = Mongo::Connection.new(options[:host], options[:port])
+          db_name = options[:db]
+        end
+        db = conn.db(db_name)
+        @cache = db.collection(options[:collection])
+      end
+
+      def key?(key, *)
+        !!self[key]
+      end
+
+      def [](key)
+        res = @cache.find_one('_id' => key_for(key))
+        res && deserialize(res['data'].to_s)
+      end
+
+      def delete(key, *)
+        string_key = key_for(key)
+
+        value = self[key]
+        @cache.remove('_id' => string_key) if value
+        value
+      end
+
+      def store(key, value, *)
+        key = key_for(key)
+        serialized_value = BSON::ByteBuffer.new serialize(value)
+        @cache.update({ '_id' => key },
+                      { '_id' => key, 'data' => serialized_value },
+                      { :upsert => true })
+      end
+
+      def clear(*)
+        @cache.remove
+      end
+    end
+  end
+end
+

data/lib/moneta/adapters/pstore.rb

@@ -0,0 +1,58 @@
+require 'pstore'
+
+module Moneta
+  module Adapters
+    class PStore < ::PStore
+      include Moneta::Defaults
+
+      def initialize(options = {})
+        options[:path] ||= File.join Dir.pwd, 'data.pstore'
+        super options[:path]
+      end
+
+      def key?(key)
+        transaction do
+          root? key_for(key)
+        end
+      end
+
+      def keys
+        transaction true do
+          roots
+        end
+      end
+
+      def [](key)
+        transaction true do
+          struct = super key_for(key)
+          struct ? struct['value'] : nil
+        end
+      end
+
+      def delete(key)
+        struct = if @transaction
+          super key_for(key)
+        else
+          transaction do
+            super key_for(key)
+          end
+        end
+        struct ? struct['value'] : nil
+      end
+
+      def store(key, value, *)
+        transaction do
+          (@table[key_for(key)] ||= {})['value'] = value
+        end
+      end
+
+      def clear(*)
+        transaction do
+          @table.keys.each do |key|
+            delete key
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moneta/adapters/rackspace.rb

@@ -0,0 +1,14 @@
+require "moneta/adapters/fog"
+
+module Moneta
+  module Adapters
+    class Rackspace < Fog
+
+      def initialize(options)
+        options[:cloud] = ::Fog::Rackspace::Files
+        super
+      end
+
+    end
+  end
+end

data/lib/moneta/adapters/redis.rb

@@ -0,0 +1,41 @@
+begin
+  require "redis"
+rescue LoadError
+  puts "You need the redis gem to use the Redis store"
+  exit
+end
+
+module Moneta
+  module Adapters
+    class Redis
+      include Defaults
+
+      def initialize(options = {})
+        @cache = ::Redis.new(options)
+      end
+
+      def key?(key, *)
+        !@cache[key_for(key)].nil?
+      end
+
+      def [](key)
+        deserialize(@cache.get(key_for(key)))
+      end
+
+      def delete(key, *)
+        string_key = key_for(key)
+        value = self[key]
+        @cache.del(string_key) if value
+        value
+      end
+
+      def store(key, value, *)
+        @cache.set(key_for(key), serialize(value))
+      end
+
+      def clear(*)
+        @cache.flushdb
+      end
+    end
+  end
+end

data/lib/moneta/adapters/s3.rb

@@ -0,0 +1,14 @@
+require "moneta/adapters/fog"
+
+module Moneta
+  module Adapters
+    class S3 < Fog
+
+      def initialize(options)
+        options[:cloud] = ::Fog::AWS::S3
+        super
+      end
+
+    end
+  end
+end

data/lib/moneta/adapters/sdbm.rb

@@ -0,0 +1,34 @@
+require "sdbm"
+
+module Moneta
+  module Adapters
+    class SDBM < ::SDBM
+      include Moneta::Defaults
+
+      def initialize(options = {})
+        raise "No :file options specified" unless file = options[:file]
+        super(file)
+      end
+
+      def [](key)
+        if val = super(key_for(key))
+          deserialize(val)
+        end
+      end
+
+      def store(key, value, *)
+        super(key_for(key), serialize(value))
+      end
+
+      def key?(key, *)
+        super(key_for(key))
+      end
+
+      def delete(key, *)
+        if val = super(key_for(key))
+          deserialize(val)
+        end
+      end
+    end
+  end
+end

data/lib/moneta/adapters/tokyo_cabinet.rb

@@ -0,0 +1,51 @@
+begin
+  require "tokyocabinet"
+rescue LoadError
+  puts "You need the tokyocabinet gem to use the tokyo cabinet store"
+  exit
+end
+
+module Moneta
+  module Adapters
+    class TokyoCabinet
+      include Defaults
+
+      def initialize(options = {})
+        file = options[:file]
+        @cache = ::TokyoCabinet::HDB.new
+        unless @cache.open(file, ::TokyoCabinet::HDB::OWRITER | ::TokyoCabinet::HDB::OCREAT)
+          puts @cache.errmsg(@cache.ecode)
+        end
+      end
+
+      def [](key)
+        deserialize(@cache[key_for(key)])
+      end
+
+      def store(key, value, *)
+        @cache[key_for(key)] = serialize(value)
+      end
+
+      def key?(key, *)
+        !!self[key]
+      end
+
+      def delete(key, *)
+        value = self[key]
+
+        if value
+          @cache.delete(key_for(key))
+          value
+        end
+      end
+
+      def clear(*)
+        @cache.clear
+      end
+
+      def close
+        @cache.close
+      end
+    end
+  end
+end

data/lib/moneta/adapters/tyrant.rb

@@ -0,0 +1,45 @@
+begin
+  require "tokyotyrant"
+rescue LoadError
+  puts "You need the tokyotyrant gem to use the Tyrant moneta store"
+  exit
+end
+
+module Moneta
+  module Adapters
+    class Tyrant
+      include Defaults
+
+      def initialize(options = {})
+        @hash = ::TokyoTyrant::RDB.new
+
+        if !@hash.open(options[:host], options[:port])
+          puts @hash.errmsg(@hash.ecode)
+        end
+      end
+
+      def key?(key, *)
+        !!self[key]
+      end
+
+      def [](key)
+        deserialize(@hash[key_for(key)])
+      end
+
+      def store(key, value, *)
+        @hash.put(key_for(key), serialize(value))
+      end
+
+      def clear(*)
+        @hash.clear
+      end
+
+      def delete(key, *)
+        if value = self[key]
+          @hash.delete(key_for(key))
+          value
+        end
+      end
+    end
+  end
+end

data/lib/moneta/adapters/xattr.rb

@@ -0,0 +1,50 @@
+begin
+  require "xattr"
+rescue LoadError
+  puts "You need the xattr gem to use the Xattr moneta store"
+  exit
+end
+require "fileutils"
+
+module Moneta
+  module Adapters
+    class Xattr
+      include Defaults
+
+      def initialize(options = {})
+        file = options[:file]
+        @hash = ::Xattr.new(file)
+        FileUtils.mkdir_p(::File.dirname(file))
+        FileUtils.touch(file)
+      end
+
+      def key?(key, *)
+        @hash.list.include?(key_for(key))
+      end
+
+      def [](key)
+        string_key = key_for(key)
+        return nil unless key?(string_key)
+        Marshal.load(@hash.get(string_key))
+      end
+
+      def store(key, value, *)
+        @hash.set(key_for(key), Marshal.dump(value))
+      end
+
+      def delete(key, *)
+        return nil unless key?(key)
+        value = self[key]
+        @hash.remove(key_for(key))
+        value
+      end
+
+      def clear(*)
+        @hash.list.each do |item|
+          @hash.remove(item)
+        end
+      end
+
+    end
+  end
+end

data/lib/moneta/adapters/yaml.rb

@@ -0,0 +1,53 @@
+require "yaml"
+require "fileutils"
+
+module Moneta
+  module Adapters
+    class YAML
+      include Moneta::Defaults
+
+      def initialize(options = {})
+        @file = File.expand_path(options[:path])
+        unless ::File.exists?(@file)
+          File.open(@file, "w") { |file| file << {}.to_yaml }
+        end
+      end
+
+      def key?(key, *)
+        yaml.has_key?(key_for(key))
+      end
+
+      def [](key)
+        string_key = key_for(key)
+        yaml[string_key]['value'] if yaml.key?(string_key)
+      end
+
+      def store(key, value, *)
+        hash = yaml
+        (hash[key_for(key)] ||= {})['value'] = value
+        save(hash)
+      end
+
+      def delete(key, *)
+        hash = yaml
+        value = self[key_for(key)]
+        hash.delete(key_for(key))
+        save(hash)
+        value
+      end
+
+      def clear(*)
+        save
+      end
+
+    private
+      def yaml
+        ::YAML.load_file(@file)
+      end
+
+      def save(hash = {})
+        ::File.open(@file, "w") { |file| file << hash.to_yaml }
+      end
+    end
+  end
+end

data/lib/moneta/builder.rb

@@ -0,0 +1,72 @@
+module Moneta
+  module Middleware
+    def self.included(klass)
+      class << klass
+        alias build new
+      end
+    end
+
+    def build(adapter)
+      @adapter = adapter
+    end
+
+    def [](key)
+      @adapter[key]
+    end
+
+    def []=(key, value)
+      @adapter[key] = value
+    end
+
+    def fetch(*args, &block)
+      @adapter.fetch(*args, &block)
+    end
+
+    def delete(key, *args)
+      @adapter.delete(key, *args)
+    end
+
+    def store(key, value, *args)
+      @adapter.store(key, value, *args)
+    end
+
+    def update_key(key, options)
+      @adapter.update_key(key, options)
+    end
+
+    def key?(key, *args)
+      @adapter.key?(key, *args)
+    end
+
+    def clear(*args)
+      @adapter.clear(*args)
+    end
+
+    def close
+      @adapter.close
+    end
+  end
+
+  class Builder
+    include Middleware
+
+    def initialize(&block)
+      @middlewares = []
+      @adapter     = nil
+      instance_eval(&block)
+    end
+
+    def use(middleware, *args, &block)
+      @middlewares << middleware.build(*args, &block)
+    end
+
+    def run(adapter, *args, &block)
+      @adapter = adapter.new(*args, &block)
+
+      @middlewares.reverse.each do |middleware|
+        @adapter = middleware.build(@adapter)
+      end
+    end
+
+  end
+end

data/lib/moneta.rb

@@ -0,0 +1,29 @@
+require "moneta/builder"
+
+module Moneta
+  module Defaults
+    def fetch(key, value = nil, *)
+      self[key] || begin
+        value ||= block_given? ? yield(key) : default
+        self[key] || value
+      end
+    end
+
+    def []=(key, value)
+      store(key, value)
+    end
+
+  private
+    def key_for(key)
+      key.is_a?(String) ? key : Marshal.dump(key)
+    end
+
+    def serialize(value)
+      Marshal.dump(value)
+    end
+
+    def deserialize(value)
+      value && Marshal.load(value)
+    end
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: dkastner-moneta
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 7
+  - 0
+  version: 0.7.0
+platform: ruby
+authors: 
+- Yehuda Katz
+- Derek Kastner
+autorequire: moneta
+bindir: bin
+cert_chain: []
+
+date: 2011-01-26 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: A unified interface to key/value stores
+email: dkastner@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- TODO
+files: 
+- lib/moneta/builder.rb
+- lib/moneta/adapters/tyrant.rb
+- lib/moneta/adapters/basic_file.rb
+- lib/moneta/adapters/pstore.rb
+- lib/moneta/adapters/rackspace.rb
+- lib/moneta/adapters/xattr.rb
+- lib/moneta/adapters/sdbm.rb
+- lib/moneta/adapters/redis.rb
+- lib/moneta/adapters/fog.rb
+- lib/moneta/adapters/datamapper.rb
+- lib/moneta/adapters/memcache.rb
+- lib/moneta/adapters/mongodb.rb
+- lib/moneta/adapters/couch.rb
+- lib/moneta/adapters/s3.rb
+- lib/moneta/adapters/lmc.rb
+- lib/moneta/adapters/memory.rb
+- lib/moneta/adapters/file.rb
+- lib/moneta/adapters/yaml.rb
+- lib/moneta/adapters/tokyo_cabinet.rb
+- lib/moneta.rb
+- LICENSE
+- README
+- Rakefile
+- TODO
+has_rdoc: true
+homepage: http://www.yehudakatz.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A unified interface to key/value stores
+test_files: []
+