thoughtless-moneta 0.6.0.1 → 0.6.0.2

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,52 @@
+begin
+  require "mongo"
+rescue LoadError
+  puts "You need the mongo gem to use the MongoDB moneta store"
+  exit
+end
+
+module Moneta
+  module Adapters
+    class MongoDB
+      include Moneta::Defaults
+
+      def initialize(options = {})
+        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])
+        @cache = conn.db(options[: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'])
+      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)
+        @cache.insert({ '_id' => key, 'data' => serialize(value) })
+      end
+
+      def clear(*)
+        @cache.remove
+      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