aeden-moneta 0.6.2

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,50 @@
+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
+* 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
+
+#[]=(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.6.2"
+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.rb

@@ -0,0 +1,76 @@
+module Moneta
+  module Expires
+    def check_expired(key)
+      if @expiration[key] && Time.now > @expiration[key]
+        @expiration.delete(key)
+        self.delete(key)
+      end
+    end
+
+    def key?(key)
+      check_expired(key)
+      super
+    end
+
+    def [](key)
+      check_expired(key)
+      super
+    end
+
+    def fetch(key, default = nil, &blk)
+      check_expired(key)
+      super
+    end
+
+    def delete(key)
+      check_expired(key)
+      super
+    end
+
+    def update_key(key, options)
+      update_options(key, options)
+    end
+
+    def store(key, value, options = {})
+      ret = super(key, value)
+      update_options(key, options)
+      ret
+    end
+
+    private
+    def update_options(key, options)
+      if options[:expires_in]
+        @expiration[key] = (Time.now + options[:expires_in])
+      end
+    end
+  end
+
+  module StringExpires
+    include Expires
+
+    def check_expired(key)
+      if @expiration[key] && Time.now > Time.at(@expiration[key].to_i)
+        @expiration.delete(key)
+        delete(key)
+      end
+    end
+
+    private
+    def update_options(key, options)
+      if options[:expires_in]
+        @expiration[key] = (Time.now + options[:expires_in]).to_i.to_s
+      end
+    end
+  end
+  
+  module Defaults
+    def fetch(key, value = nil)
+      value ||= block_given? ? yield(key) : default
+      self[key] || value
+    end
+    
+    def store(key, value, options = {})
+      self[key] = value
+    end        
+  end
+end

data/lib/moneta/berkeley.rb

@@ -0,0 +1,53 @@
+begin
+  require 'bdb'
+rescue LoadError
+  puts "You need bdb gem to use Bdb moneta store"
+  exit
+end
+
+module Moneta
+
+  class Berkeley
+    include Defaults
+
+    def initialize(options={})
+      file = @file = options[:file]
+      @db = Bdb::Db.new()
+      @db.open(nil, file, nil, Bdb::Db::BTREE, Bdb::DB_CREATE, 0)
+      unless options[:skip_expires]
+        @expiration = Moneta::Berkeley.new(:file => "#{file}_expiration", :skip_expires => true )
+        self.extend(StringExpires)
+      end
+    end
+    
+    module Implementation
+      def key?(key)
+        nil | self[key]
+      end
+
+      alias has_key? key?
+
+      def []=(key,value)
+        @db[key] = value
+      end
+
+      def [](key)
+        @db[key]
+      end
+
+      def delete(key)
+        value = self[key]
+        @db.del(nil,key,0) if value
+        value
+      end
+
+      def clear
+        @db.truncate(nil)
+      end
+    end
+
+    include Implementation
+
+  end
+
+end

data/lib/moneta/couch.rb

@@ -0,0 +1,63 @@
+begin
+  require "couchrest"
+rescue LoadError
+  puts "You need the couchrest gem to use the CouchDB store"
+  exit
+end
+
+module Moneta
+  class Couch
+    include Defaults
+    
+    def initialize(options = {})
+      @db = ::CouchRest.database!(options[:db])
+      unless options[:skip_expires]
+        @expiration = Moneta::Couch.new(:db => "#{options[:db]}_expiration", :skip_expires => true)
+        self.extend(StringExpires)
+      end
+    end
+
+    def key?(key)
+      !self[key].nil?
+    rescue RestClient::ResourceNotFound
+      false
+    end
+
+    alias has_key? key?
+
+    def [](key)
+      @db.get(key)["data"]
+    rescue RestClient::ResourceNotFound
+      nil
+    end
+
+    def []=(key, value)
+      @db.save_doc("_id" => key, :data => value)
+    rescue RestClient::RequestFailed
+      self[key]
+    end
+
+    def delete(key)
+      value = @db.get(key)
+      @db.delete_doc({"_id" => value["_id"], "_rev" => value["_rev"]}) if value
+      value["data"]
+    rescue RestClient::ResourceNotFound
+      nil
+    end
+
+    def update_key(key, options = {})
+      val = self[key]
+      self.store(key, val, options)
+    rescue RestClient::ResourceNotFound
+      nil
+    end
+
+    def clear
+      @db.recreate!
+    end
+
+    def delete_store
+      @db.delete!
+    end
+  end
+end

data/lib/moneta/datamapper.rb

@@ -0,0 +1,117 @@
+begin
+  gem "dm-core", "0.9.10"
+  require "dm-core"
+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
+  property :expires, Time
+
+  def self.value(key)
+    obj = self.get(key)
+    obj && obj.value
+  end
+end
+
+module Moneta
+  class DataMapper
+    class Expiration
+      def initialize(klass, repository)
+        @klass = klass
+        @repository = repository
+      end
+
+      def [](key)
+        if obj = get(key)
+          obj.expires
+        end
+      end
+
+      def []=(key, value)
+        obj = get(key)
+        obj.expires = value
+        obj.save(@repository)
+      end
+
+      def delete(key)
+        obj = get(key)
+        obj.expires = nil
+        obj.save(@repository)
+      end
+
+      private
+      def get(key)
+        repository(@repository) { @klass.get(key) }
+      end
+    end
+
+    def initialize(options = {})
+      @repository = options.delete(:repository) || :moneta
+      ::DataMapper.setup(@repository, options[:setup])
+      repository_context { MonetaHash.auto_upgrade! }
+      @hash = MonetaHash
+      @expiration = Expiration.new(MonetaHash, @repository)
+    end
+
+    module Implementation
+      def key?(key)
+        repository_context { !!@hash.get(key) }
+      end
+
+      def has_key?(key)
+        repository_context { !!@hash.get(key) }
+      end
+
+      def [](key)
+        repository_context { @hash.value(key) }
+      end
+
+      def []=(key, value)
+        repository_context {
+          obj = @hash.get(key)
+          if obj
+            obj.update(key, value)
+          else
+            @hash.create(:the_key => key, :value => value)
+          end
+        }
+      end
+
+      def fetch(key, value = nil)
+        repository_context {
+          value ||= block_given? ? yield(key) : default
+          self[key] || value
+        }
+      end
+
+      def delete(key)
+        repository_context {
+          value = self[key]
+          @hash.all(:the_key => key).destroy!
+          value
+        }
+      end
+
+      def store(key, value, options = {})
+        repository_context { self[key] = value }
+      end
+
+      def clear
+        repository_context { @hash.all.destroy! }
+      end
+
+      private
+      def repository_context
+        repository(@repository) { yield }
+      end
+    end
+    include Implementation
+    include Expires
+  end
+end

data/lib/moneta/file.rb

@@ -0,0 +1,91 @@
+begin
+  require "xattr"
+rescue LoadError
+  puts "You need the xattr gem to use the File moneta store"
+  exit
+end
+require "fileutils"
+
+module Moneta
+  class File
+    class Expiration
+      def initialize(directory)
+        @directory = directory
+      end
+      
+      def [](key)
+        attrs = xattr(key)
+        ret = Marshal.load(attrs.get("moneta_expires"))
+      rescue Errno::ENOENT, SystemCallError
+      end
+      
+      def []=(key, value)
+        attrs = xattr(key)
+        attrs.set("moneta_expires", Marshal.dump(value))
+      end
+      
+      def delete(key)
+        attrs = xattr(key)
+        attrs.remove("moneta_expires")
+      end
+
+      private
+      def xattr(key)
+        ::Xattr.new(::File.join(@directory, key))
+      end
+    end
+    
+    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
+      
+      @expiration = Expiration.new(@directory)
+    end
+    
+    module Implementation
+      def key?(key)
+        ::File.exist?(path(key))
+      end
+      
+      alias has_key? key?
+      
+      def [](key)
+        if ::File.exist?(path(key))
+          Marshal.load(::File.read(path(key)))
+        end
+      end
+      
+      def []=(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)
+      end
+    end
+    include Implementation
+    include Defaults
+    include Expires
+    
+  end
+end

data/lib/moneta/lmc.rb

@@ -0,0 +1,52 @@
+begin
+  require "localmemcache"
+rescue LoadError
+  puts "You need the localmemcache gem to use the LMC moneta store"
+  exit
+end
+
+module Moneta
+  class Expiration
+    def initialize(hash)
+      @hash = hash
+    end
+    
+    def [](key)         @hash["#{key}__!__expiration"]          end
+    def []=(key, value) @hash["#{key}__!__expiration"] = value  end
+      
+    def delete(key)
+      key = "#{key}__!__expiration"
+      value = @hash[key]
+      @hash.delete(key)
+      value
+    end
+  end
+  
+  class LMC
+    include Defaults
+
+    module Implementation
+      def initialize(options = {})
+        @hash = LocalMemCache.new(:filename => options[:filename])
+        @expiration = Expiration.new(@hash)
+      end    
+
+      def [](key)         @hash[key]          end
+      def []=(key, value) @hash[key] = value  end
+      def clear()         @hash.clear         end
+
+      def key?(key)
+        @hash.keys.include?(key)
+      end
+
+      def delete(key)
+        value = @hash[key]
+        @hash.delete(key)
+        value
+      end      
+    end
+    include Implementation
+    include StringExpires
+   
+  end
+end

data/lib/moneta/memcache.rb

@@ -0,0 +1,52 @@
+begin
+  require "memcached"
+rescue LoadError
+  require "memcache"
+rescue LoadError
+  puts "You need the memcache gem to use the Memcache moneta store"
+  exit
+end
+
+module Moneta
+  class Memcache
+    include Defaults
+    
+    def initialize(options = {})
+      @cache = MemCache.new(options.delete(:server), options)
+    end
+
+    def key?(key)
+      !self[key].nil?
+    end
+
+    alias has_key? key?
+
+    def [](key)
+      @cache.get(key)
+    end
+
+    def []=(key, value)
+      store(key, value)
+    end
+
+    def delete(key)
+      value = self[key]
+      @cache.delete(key) if value
+      value
+    end
+
+    def store(key, value, options = {})
+      args = [key, value, options[:expires_in]].compact
+      @cache.set(*args)
+    end
+
+    def update_key(key, options = {})
+      val = self[key]
+      self.store(key, val, options)
+    end
+
+    def clear
+      @cache.flush_all
+    end
+  end
+end

data/lib/moneta/memory.rb

@@ -0,0 +1,11 @@
+module Moneta
+  class Memory < Hash
+    include Expires
+    
+    def initialize(*args)
+      @expiration = {}
+      super
+    end    
+        
+  end
+end

data/lib/moneta/mongodb.rb

@@ -0,0 +1,58 @@
+begin
+  require "mongo"
+rescue LoadError
+  puts "You need the mongo gem to use the MongoDB moneta store"
+  exit
+end
+
+module Moneta
+  class MongoDB
+    include Defaults
+    
+    def initialize(options = {})
+      options = {
+        :host => ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost',
+        :port => ENV['MONGO_RUBY_DRIVER_PORT'] || XGen::Mongo::Driver::Mongo::DEFAULT_PORT,
+        :db => 'cache',
+        :collection => 'cache'
+      }.update(options)
+      conn = XGen::Mongo::Driver::Mongo.new(options[:host], options[:port])
+      @cache = conn.db(options[:db]).collection(options[:collection])
+    end
+
+    def key?(key)
+      !!self[key]
+    end
+
+    def [](key)
+      res = @cache.find_first('_id' => key)
+      res = nil if res && res['expires'] && Time.now > res['expires']
+      res && res['data']
+    end
+
+    def []=(key, value)
+      store(key, value)
+    end
+
+    def delete(key)
+      value = self[key]
+      @cache.remove('_id' => key) if value
+      value
+    end
+
+    def store(key, value, options = {})
+      exp = options[:expires_in] ? (Time.now + options[:expires_in]) : nil
+      @cache.repsert({ '_id' => key }, { '_id' => key, 'data' => value, 'expires' => exp })
+    end
+
+    def update_key(key, options = {})
+      val = self[key]
+      self.store(key, val, options)
+    end
+
+    def clear
+      @cache.clear
+    end
+  end
+end
+

data/lib/moneta/redis.rb

@@ -0,0 +1,49 @@
+begin
+  require "redis"
+rescue LoadError
+  puts "You need the redis gem to use the Redis store"
+  exit
+end
+
+module Moneta
+  class Redis
+    include Defaults
+    
+    def initialize(options = {})
+      @cache = ::Redis.new(options)
+    end
+    
+    def key?(key)
+      !@cache[key].nil?
+    end
+    
+    alias has_key? key?
+    
+    def [](key)
+      @cache.get(key)
+    end
+    
+    def []=(key, value)
+      store(key, value)
+    end
+        
+    def delete(key)
+      value = @cache[key]
+      @cache.delete(key) if value
+      value
+    end
+    
+    def store(key, value, options = {})
+      @cache.set(key, value, options[:expires_in])
+    end
+    
+    def update_key(key, options = {})
+      val = @cache[key]
+      self.store(key, val, options)
+    end
+    
+    def clear
+      @cache.flush_db
+    end
+  end
+end

data/lib/moneta/rufus.rb

@@ -0,0 +1,41 @@
+begin
+  require "rufus/tokyo"
+rescue LoadError
+  puts "You need the rufus gem to use the Rufus moneta store"
+  exit
+end
+
+module Moneta
+  class BasicRufus < ::Rufus::Tokyo::Cabinet 
+    include Defaults
+       
+    def initialize(options = {})
+      file = options[:file]
+      super("#{file}.tch")
+    end
+    
+    def key?(key)
+      !!self[key]
+    end
+    
+    def [](key)
+      if val = super
+        Marshal.load(val.unpack("m")[0])
+      end
+    end
+    
+    def []=(key, value)
+      super(key, [Marshal.dump(value)].pack("m"))
+    end    
+  end
+  
+  class Rufus < BasicRufus
+    include Expires
+    
+    def initialize(options = {})
+      file = options[:file]
+      @expiration = BasicRufus.new(:file => "#{file}_expires")
+      super
+    end
+  end
+end

data/lib/moneta/s3.rb

@@ -0,0 +1,164 @@
+begin
+  require "right_aws"
+rescue LoadError
+  puts "You need the RightScale AWS gem to use the S3 moneta store"
+  exit  
+end
+
+module Moneta
+  # An S3 implementation of Moneta
+  #
+  # Example usage:
+  #
+  #   require 'rubygems'
+  #   require 'moneta'
+  #   require 'moneta/s3'
+  #
+  #   store = Moneta::S3.new(
+  #     :access_key_id => 'ACCESS_KEY_ID', 
+  #     :secret_access_key => 'SECRET_ACCESS_KEY', 
+  #     :bucket => 'a_bucket'
+  #   )
+  #   store['somefile'] 
+  class S3
+    include Defaults
+    
+    # Initialize the Moneta::S3 store.
+    #
+    # Required values passed in the options hash:
+    # * <tt>:access_key_id</tt>: The access id key
+    # * <tt>:secret_access_key</tt>: The secret key
+    # * <tt>:bucket</tt>: The name of bucket. Will be created if it doesn't
+    # exist.
+    # * <tt>:multi_thread</tt>: Set to true if using threading
+    def initialize(options = {})
+      validate_options(options)
+      s3 = RightAws::S3.new(
+        options[:access_key_id], 
+        options[:secret_access_key], 
+        {
+          :logger => logger, 
+          :multi_thread => options.delete(:multi_thread) || false
+        }
+      )
+      @bucket = s3.bucket(options.delete(:bucket), true)
+    end
+    
+    def key?(key)
+      !s3_key(key).nil?
+    end
+    
+    alias has_key? key?
+    
+    def [](key)
+      get(key)
+    end
+    
+    def []=(key, value)
+      store(key, value)
+    end
+        
+    def delete(key)
+      k = s3_key(key)
+      if k
+        value = k.get
+        k.delete
+        value
+      end
+    end
+    
+    # Store the key/value pair.
+    # 
+    # Options:
+    # *<tt>:meta_headers</tt>: Meta headers passed to S3
+    # *<tt>:perms</tt>: Permissions passed to S3
+    # *<tt>:headers</tt>: Headers sent as part of the PUT request
+    # *<tt>:expires_in</tt>: Number of seconds until expiration
+    def store(key, value, options = {})
+      debug "store(key=#{key}, value=#{value}, options=#{options.inspect})"
+      meta_headers = meta_headers_from_options(options)
+      perms = options[:perms]
+      headers = options[:headers] || {}
+      
+      case value
+      when IO
+        @bucket.put(key, value.read, meta_headers, perms, headers)
+      else
+        @bucket.put(key, value, meta_headers, perms, headers)
+      end
+    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
+      @bucket.clear
+    end
+    
+    protected
+    def logger
+      @logger ||= begin
+        logger = Logger.new(STDOUT)
+        logger.level = Logger::FATAL
+        logger
+      end
+    end
+    
+    private
+    def validate_options(options)
+      unless options[:access_key_id]
+        raise RuntimeError, ":access_key_id is required in options"
+      end
+      unless options[:secret_access_key]
+        raise RuntimeError, ":secret_access_key is required in options"
+      end
+      unless options[:bucket]
+        raise RuntimeError, ":bucket is required in options"
+      end
+    end
+    
+    def get(key)
+      k = s3_key(key)
+      k.nil? ? nil : k.get
+    end
+    
+    def s3_key(key, nil_if_expired=true)
+      begin
+        s3_key = @bucket.key(key, true)
+        if s3_key.exists?
+          logger.debug "[Moneta::S3] key exists: #{key}"
+          if s3_key.meta_headers.has_key?('expires-at')
+            expires_at = Time.parse(s3_key.meta_headers['expires-at'])
+            if Time.now > expires_at && nil_if_expired
+              # TODO delete the object?
+              debug "key expired: #{key} (@#{s3_key.meta_headers['expires-at']})"
+              return nil
+            end
+          end
+          return s3_key
+        else
+          debug "key does not exist: #{key}"
+        end
+      rescue RightAws::AwsError => e
+        debug "key does not exist: #{key}"
+      end
+      nil
+    end
+    
+    def meta_headers_from_options(options={})
+      meta_headers = options[:meta_headers] || {}
+      if options[:expires_in]
+        meta_headers['expires-at'] = (Time.now + options[:expires_in]).rfc2822
+      end
+      debug "setting expires-at: #{meta_headers['expires-at']}"
+      meta_headers
+    end
+    
+    def debug(message)
+      logger.debug "[Moneta::S3] #{message}"
+    end
+  end
+end

data/lib/moneta/sdbm.rb

@@ -0,0 +1,33 @@
+require "sdbm"
+
+module Moneta
+  class BasicSDBM < ::SDBM
+    include Defaults
+
+    def [](key)
+      if val = super
+        Marshal.load(val)
+      end
+    end
+
+    def []=(key, value)
+      super(key, Marshal.dump(value))
+    end
+
+    def delete(key)
+      if val = super
+        Marshal.load(val)
+      end
+    end
+  end
+
+  class SDBM < BasicSDBM
+    include Expires
+
+    def initialize(options = {})
+      raise "No :file option specified" unless file = options[:file]
+      @expiration = BasicSDBM.new("#{file}_expires")
+      super(file)
+    end
+  end
+end

data/lib/moneta/tyrant.rb

@@ -0,0 +1,58 @@
+begin
+  require "rufus/tokyo/tyrant"
+rescue LoadError
+  puts "You need the rufus gem to use the Tyrant moneta store"
+  exit
+end
+
+module Moneta
+  class Tyrant < ::Rufus::Tokyo::Tyrant
+    include Defaults
+    
+    module Implementation
+      def initialize(options = {})
+        host = options[:host]
+        port = options[:port]
+        super(host, port)
+      end      
+      
+      def key?(key)
+        !!self[key]
+      end
+    
+      def [](key)
+        if val = super
+          Marshal.load(val.unpack("m")[0])
+        end
+      end
+    
+      def []=(key, value)
+        super(key, [Marshal.dump(value)].pack("m"))
+      end    
+    end
+    
+    include Implementation
+    include Expires
+    
+    def initialize(options = {})
+      super
+      @expiration = Expiration.new(options)
+    end
+    
+    class Expiration < ::Rufus::Tokyo::Tyrant
+      include Implementation
+      
+      def [](key)
+        super("#{key}__expiration")
+      end
+      
+      def []=(key, value)
+        super("#{key}__expiration", value)
+      end
+      
+      def delete(key)
+        super("#{key}__expiration")
+      end
+    end
+  end  
+end

data/lib/moneta/xattr.rb

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

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: aeden-moneta
+version: !ruby/object:Gem::Version 
+  version: 0.6.2
+platform: ruby
+authors: 
+- Yehuda Katz
+autorequire: moneta
+bindir: bin
+cert_chain: []
+
+date: 2009-06-03 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: A unified interface to key/value stores
+email: wycats@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- TODO
+files: 
+- LICENSE
+- README
+- Rakefile
+- TODO
+- lib/moneta
+- lib/moneta/berkeley.rb
+- lib/moneta/couch.rb
+- lib/moneta/datamapper.rb
+- lib/moneta/file.rb
+- lib/moneta/lmc.rb
+- lib/moneta/memcache.rb
+- lib/moneta/memory.rb
+- lib/moneta/mongodb.rb
+- lib/moneta/redis.rb
+- lib/moneta/rufus.rb
+- lib/moneta/s3.rb
+- lib/moneta/sdbm.rb
+- lib/moneta/tyrant.rb
+- lib/moneta/xattr.rb
+- lib/moneta.rb
+has_rdoc: true
+homepage: http://www.yehudakatz.com
+post_install_message: 
+rdoc_options: []
+
+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.2.0
+signing_key: 
+specification_version: 2
+summary: A unified interface to key/value stores
+test_files: []
+