thoughtless-moneta 0.6.0.1 → 0.6.0.2

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: thoughtless-moneta
 version: !ruby/object:Gem::Version 
-  version: 0.6.0.1
+  version: 0.6.0.2
 platform: ruby
 authors: 
 - Yehuda Katz
@@ -9,7 +9,7 @@ autorequire: thoughtless-moneta
 bindir: bin
 cert_chain: []
 
-date: 2009-10-18 00:00:00 -07:00
+date: 2010-08-12 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -28,22 +28,24 @@ files:
 - README
 - Rakefile
 - TODO
-- lib/moneta/redis.rb
-- lib/moneta/lmc.rb
-- lib/moneta/rufus.rb
-- lib/moneta/sdbm.rb
-- lib/moneta/s3.rb
-- lib/moneta/couch.rb
-- lib/moneta/xattr.rb
-- lib/moneta/berkeley.rb
-- lib/moneta/basic_file.rb
-- lib/moneta/memory.rb
-- lib/moneta/datamapper.rb
-- lib/moneta/memcache.rb
-- lib/moneta/mongodb.rb
-- lib/moneta/yaml.rb
-- lib/moneta/file.rb
-- lib/moneta/tyrant.rb
+- lib/moneta/builder.rb
+- lib/moneta/adapters/couch.rb
+- lib/moneta/adapters/tyrant.rb
+- lib/moneta/adapters/yaml.rb
+- lib/moneta/adapters/s3.rb
+- lib/moneta/adapters/basic_file.rb
+- lib/moneta/adapters/mongodb.rb
+- lib/moneta/adapters/rackspace.rb
+- lib/moneta/adapters/file.rb
+- lib/moneta/adapters/redis.rb
+- lib/moneta/adapters/sdbm.rb
+- lib/moneta/adapters/datamapper.rb
+- lib/moneta/adapters/tokyo_cabinet.rb
+- lib/moneta/adapters/lmc.rb
+- lib/moneta/adapters/memcache.rb
+- lib/moneta/adapters/xattr.rb
+- lib/moneta/adapters/memory.rb
+- lib/moneta/adapters/fog.rb
 - lib/moneta.rb
 has_rdoc: true
 homepage: http://www.yehudakatz.com

data/lib/moneta/basic_file.rb

@@ -1,113 +0,0 @@
-#
-#  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 File.join(File.dirname(__FILE__), "..", "moneta.rb")
-
-module Moneta
-  class BasicFile
-    include Defaults
-    
-    def initialize(options = {})
-      @namespace = options[:namespace]
-      @directory = ::File.join(options[:path], @namespace.to_s)
-      
-      @expires = !options[:skip_expires]
-
-      ensure_directory_created(@directory)
-    end
-    
-    def key?(key)
-      !self[key].nil?
-    end
-    
-    alias has_key? key?
-    
-    def [](key)
-      if ::File.exist?(path(key))
-        data = raw_get(key)
-        if @expires
-          if data[:expires_at].nil? || data[:expires_at] > Time.now
-            data[:value]
-          else
-            delete!(key)
-          end
-        else
-          data
-        end
-      end
-    end
-    
-    def raw_get(key)
-      Marshal.load(::File.read(path(key)))
-    end
-    
-    def []=(key, value)
-      store(key, value)
-    end
-    
-    def store(key, value, options = {})
-      ensure_directory_created(::File.dirname(path(key)))
-      ::File.open(path(key), "w") do |file|
-        if @expires
-          data = {:value => value}
-          if options[:expires_in]
-            data[:expires_at] = Time.now + options[:expires_in]
-          end
-          contents = Marshal.dump(data)
-        else
-          contents = Marshal.dump(value)
-        end
-        file.puts(contents)
-      end
-    end
-    
-    def update_key(key, options)
-      store(key, self[key], options)
-    end
-    
-    def delete!(key)
-      FileUtils.rm(path(key))
-      nil
-    rescue Errno::ENOENT
-    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.to_s)
-    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

data/lib/moneta/berkeley.rb

@@ -1,53 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,117 +0,0 @@
-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