juno 0.1.1 → 0.2.0

data/lib/juno/adapters/localmemcache.rb

@@ -0,0 +1,18 @@
+require 'localmemcache'
+
+module Juno
+  module Adapters
+    class LocalMemCache < Memory
+      def initialize(options = {})
+        raise 'No option :file specified' unless options[:file]
+        @memory = ::LocalMemCache.new(:filename => options[:file])
+      end
+
+      def delete(key, options = {})
+        value = load(key, options)
+        @memory.delete(key)
+        value
+      end
+    end
+  end
+end

data/lib/juno/adapters/memcached.rb

@@ -0,0 +1,11 @@
+module Juno
+  module Adapters
+    begin
+      require 'juno/adapters/memcached_native'
+      Memcached = MemcachedNative
+    rescue LoadError
+      require 'juno/adapters/memcached_dalli'
+      Memcached = MemcachedDalli
+    end
+  end
+end

data/lib/juno/adapters/memcached_dalli.rb

@@ -0,0 +1,46 @@
+require 'dalli'
+
+module Juno
+  module Adapters
+    class MemcachedDalli < Base
+      def initialize(options = {})
+        server = options.delete(:server) || 'localhost:11211'
+        @cache = ::Dalli::Client.new(server, options)
+      end
+
+      def key?(key, options = {})
+        !!@cache.get(key)
+      end
+
+      def load(key, options = {})
+        value = @cache.get(key)
+        if value && options.include?(:expires)
+          store(key, value, options)
+        else
+          value
+        end
+      end
+
+      def store(key, value, options = {})
+        @cache.set(key, value, options[:expires])
+        value
+      end
+
+      def delete(key, options = {})
+        value = @cache.get(key)
+        @cache.delete(key)
+        value
+      end
+
+      def clear(options = {})
+        @cache.flush_all
+        self
+      end
+
+      def close
+        @cache.close
+        nil
+      end
+    end
+  end
+end

data/lib/juno/adapters/memcached_native.rb

@@ -0,0 +1,47 @@
+require 'memcached'
+
+module Juno
+  module Adapters
+    class MemcachedNative < Base
+      def initialize(options = {})
+        server = options.delete(:server) || 'localhost:11211'
+        options.merge!(:prefix_key => options.delete(:namespace)) if options[:namespace]
+        @cache = ::Memcached.new(server, options)
+      end
+
+      def key?(key, options = {})
+        @cache.get(key, false)
+        true
+      rescue ::Memcached::NotFound
+        false
+      end
+
+      def load(key, options = {})
+        value = @cache.get(key, false)
+        if value && options.include?(:expires)
+          store(key, value, options)
+        else
+          value
+        end
+      rescue ::Memcached::NotFound
+      end
+
+      def delete(key, options = {})
+        value = @cache.get(key, false)
+        @cache.delete(key)
+        value
+      rescue ::Memcached::NotFound
+      end
+
+      def store(key, value, options = {})
+        @cache.set(key, value, options[:expires] || @cache.options[:default_ttl], false)
+        value
+      end
+
+      def clear(options = {})
+        @cache.flush
+        self
+      end
+    end
+  end
+end

data/lib/juno/adapters/memory.rb

@@ -0,0 +1,30 @@
+module Juno
+  module Adapters
+    class Memory < Base
+      def initialize(options = {})
+        @memory = {}
+      end
+
+      def key?(key, options = {})
+        @memory.has_key?(key)
+      end
+
+      def load(key, options = {})
+        @memory[key]
+      end
+
+      def store(key, value, options = {})
+        @memory[key] = value
+      end
+
+      def delete(key, options = {})
+        @memory.delete(key)
+      end
+
+      def clear(options = {})
+        @memory.clear
+        self
+      end
+    end
+  end
+end

data/lib/juno/adapters/mongo.rb

@@ -0,0 +1,43 @@
+require 'mongo'
+
+module Juno
+  module Adapters
+    class Mongo < Base
+      def initialize(options = {})
+        collection = options.delete(:collection) || 'juno'
+        host = options.delete(:host) || 'localhost'
+        port = options.delete(:port) || ::Mongo::Connection::DEFAULT_PORT
+        db = options.delete(:db) || 'juno'
+        connection = ::Mongo::Connection.new(host, port, options)
+        @collection = connection.db(db).collection(collection)
+      end
+
+      def key?(key, options = {})
+        !!load(key, options)
+      end
+
+      def load(key, options = {})
+        value = @collection.find_one('_id' => key)
+        value ? value['data'] : nil
+      end
+
+      def delete(key, options = {})
+        value = load(key, options)
+        @collection.remove('_id' => key) if value
+        value
+      end
+
+      def store(key, value, options = {})
+        @collection.update({ '_id' => key },
+                      { '_id' => key, 'data' => value },
+                      { :upsert => true })
+        value
+      end
+
+      def clear(options = {})
+        @collection.remove
+        self
+      end
+    end
+  end
+end

data/lib/juno/adapters/null.rb

@@ -0,0 +1,28 @@
+module Juno
+  module Adapters
+    class Null < Base
+      def initialize(options = {})
+      end
+
+      def key?(key, options = {})
+        false
+      end
+
+      def load(key, options = {})
+        nil
+      end
+
+      def store(key, value, options = {})
+        value
+      end
+
+      def delete(key, options = {})
+        nil
+      end
+
+      def clear(options = {})
+        self
+      end
+    end
+  end
+end

data/lib/juno/adapters/pstore.rb

@@ -0,0 +1,51 @@
+require 'pstore'
+
+module Juno
+  module Adapters
+    class PStore < Base
+      def initialize(options = {})
+        raise 'No option :file specified' unless options[:file]
+        FileUtils.mkpath(::File.dirname(options[:file]))
+        @pstore = new_store(options)
+      end
+
+      def key?(key, options = {})
+        @pstore.transaction(true) { @pstore.root?(key) }
+      end
+
+      def load(key, options = {})
+        @pstore.transaction(true) { @pstore[key] }
+      end
+
+      def delete(key, options = {})
+        @pstore.transaction { @pstore.delete(key) }
+      end
+
+      def store(key, value, options = {})
+        @pstore.transaction { @pstore[key] = value }
+      end
+
+      def clear(options = {})
+        @pstore.transaction do
+          @pstore.roots.each do |key|
+            @pstore.delete(key)
+          end
+        end
+        self
+      end
+
+      protected
+
+      if RUBY_VERSION > '1.9'
+        def new_store(options)
+          # Create a thread-safe pstore by default
+          ::PStore.new(options[:file], options.include?(:thread_safe) ? options[:thread_safe] : true)
+        end
+      else
+        def new_store(options)
+          ::PStore.new(options[:file])
+        end
+      end
+    end
+  end
+end

data/lib/juno/adapters/redis.rb

@@ -0,0 +1,43 @@
+require 'redis'
+
+module Juno
+  module Adapters
+    class Redis < Base
+      def initialize(options = {})
+        @redis = ::Redis.new(options)
+      end
+
+      def key?(key, options = {})
+        @redis.exists(key)
+      end
+
+      def load(key, options = {})
+        value = @redis.get(key)
+        if value && (expires = options[:expires])
+          @redis.expire(key, expires)
+        end
+        value
+      end
+
+      def delete(key, options = {})
+        if value = load(key, options)
+          @redis.del(key)
+          value
+        end
+      end
+
+      def store(key, value, options = {})
+        @redis.set(key, value)
+        if expires = options[:expires]
+          @redis.expire(key, expires)
+        end
+        value
+      end
+
+      def clear(options = {})
+        @redis.flushdb
+        self
+      end
+    end
+  end
+end

data/lib/juno/adapters/riak.rb

@@ -0,0 +1,46 @@
+# Copyright: 2011 TMX Credit
+# Author: Potapov Sergey (aka Blake)
+
+require 'riak'
+
+module Juno
+  module Adapters
+    class Riak < Base
+      def initialize(options = {})
+        bucket = options.delete(:bucket) || 'juno'
+        @bucket = ::Riak::Client.new(options).bucket(bucket)
+      end
+
+      def key?(key, options = {})
+        @bucket.exists?(key, options)
+      end
+
+      def load(key, options = {})
+        @bucket.get(key, options).raw_data
+      rescue ::Riak::FailedRequest => ex
+        nil
+      end
+
+      def delete(key, options = {})
+        value = load(key, options)
+        @bucket.delete(key, options)
+        value
+      end
+
+      def store(key, value, options = {})
+        obj = ::Riak::RObject.new(@bucket, key)
+        obj.content_type = 'application/octet-stream'
+        obj.raw_data = value
+        obj.store(options)
+        value
+      end
+
+      def clear(options = {})
+        @bucket.keys do |keys|
+          keys.each{ |key| @bucket.delete(key) }
+        end
+        self
+      end
+    end
+  end
+end

data/lib/juno/adapters/sdbm.rb

@@ -0,0 +1,27 @@
+require 'sdbm'
+
+module Juno
+  module Adapters
+    class SDBM < Memory
+      def initialize(options = {})
+        raise 'No option :file specified' unless options[:file]
+        @memory = ::SDBM.new(options[:file])
+      end
+
+      def close
+        @memory.close
+        nil
+      end
+
+      def store(key, value, options = {})
+        super
+        value
+      rescue SDBMError
+        # SDBM is not very robust!
+        # You shouldn't put to much data into it, otherwise
+        # it might raise a SDBMError.
+        value
+      end
+    end
+  end
+end

data/lib/juno/adapters/sequel.rb

@@ -0,0 +1,50 @@
+require 'sequel'
+
+module Juno
+  module Adapters
+    class Sequel < Base
+      def initialize(options = {})
+        raise 'No option :db specified' unless db = options.delete(:db)
+        @table = options.delete(:table) || :juno
+        @db = ::Sequel.connect(db, options)
+        @db.create_table?(@table) do
+          primary_key :k
+          String :k
+          String :v
+        end
+      end
+
+      def key?(key, options = {})
+        !!sequel_table[:k => key]
+      end
+
+      def load(key, options = {})
+        result = sequel_table[:k => key]
+        result ? result[:v] : nil
+      end
+
+      def store(key, value, options = {})
+        sequel_table.insert(:k => key, :v => value)
+        value
+      end
+
+      def delete(key, options = {})
+        if value = load(key, options)
+          sequel_table.filter(:k => key).delete
+          value
+        end
+      end
+
+      def clear(options = {})
+        sequel_table.delete
+        self
+      end
+
+      private
+
+      def sequel_table
+        @sequel_table ||= @db[@table]
+      end
+    end
+  end
+end

data/lib/juno/adapters/sqlite.rb

@@ -0,0 +1,52 @@
+require 'sqlite3'
+
+module Juno
+  module Adapters
+    class Sqlite < Base
+      def initialize(options = {})
+        raise 'No option :file specified' unless options[:file]
+        table = options[:table] || 'juno'
+        @db = ::SQLite3::Database.new(options[:file])
+        @db.execute("create table if not exists #{table} (key string primary key, value string)")
+        @select = @db.prepare("select value from #{table} where key = ?")
+        @insert = @db.prepare("insert into #{table} values (?, ?)")
+        @delete = @db.prepare("delete from #{table} where key = ?")
+        @clear = @db.prepare("delete from #{table}")
+      end
+
+      def key?(key, options = {})
+        !@select.execute!(key).empty?
+      end
+
+      def load(key, options = {})
+        rows = @select.execute!(key)
+        rows.empty? ? nil : rows.first.first
+      end
+
+      def store(key, value, options = {})
+        @insert.execute!(key, value)
+        value
+      end
+
+      def delete(key, options = {})
+        value = load(key, options)
+        @delete.execute!(key)
+        value
+      end
+
+      def clear(options = {})
+        @clear.execute!
+        self
+      end
+
+      def close
+        @select.close
+        @insert.close
+        @delete.close
+        @clear.close
+        @db.close
+        nil
+      end
+    end
+  end
+end

data/lib/juno/adapters/tokyocabinet.rb

@@ -0,0 +1,33 @@
+require 'tokyocabinet'
+
+module Juno
+  module Adapters
+    class TokyoCabinet < Memory
+      def initialize(options = {})
+        file = options[:file]
+        raise 'No option :file specified' unless options[:file]
+        @memory = ::TokyoCabinet::HDB.new
+        unless @memory.open(file, ::TokyoCabinet::HDB::OWRITER | ::TokyoCabinet::HDB::OCREAT)
+          raise @memory.errmsg(@memory.ecode)
+        end
+      end
+
+      def key?(key, options = {})
+        !!load(key, options)
+      end
+
+      def delete(key, options = {})
+        value = load(key, options)
+        if value
+          @memory.delete(key)
+          value
+        end
+      end
+
+      def close
+        @memory.close
+        nil
+      end
+    end
+  end
+end

data/lib/juno/adapters/yaml.rb

@@ -0,0 +1,13 @@
+require 'yaml/store'
+
+module Juno
+  module Adapters
+    class YAML < Juno::Adapters::PStore
+      protected
+
+      def new_store(options)
+        ::YAML::Store.new(options[:file])
+      end
+    end
+  end
+end

data/lib/juno/base.rb

@@ -1,72 +1,29 @@
 module Juno
   # Simple interface to key/value stores with Hash-like interface.
-  #
-  # @abstract
   class Base
-    # Exists the value with key
-    #
-    # @param [Object] key
-    # @return [Boolean]
-    # @param [Hash] options
-    # @api public
-    def key?(key, options = {})
-      @store.has_key?(key_for(key))
-    end
-
-    def has_key?(key, options = {})
-      key?(key, options)
-    end
-
-    # Fetch value with key. Return nil if the key doesn't exist
-    #
-    # @param [Object] key
-    # @return [Object] value
-    # @api public
-    def [](key)
-      deserialize(@store[key_for(key)])
-    end
-
-    # Store value with key
-    #
-    # @param [Object] key
-    # @param [Object] value
-    # @param [Hash] options
-    # @return value
+    # Explicitly close the store
     # @api public
-    def store(key, value, options = {})
-      @store[key_for(key)] = serialize(value)
-      value
+    def close
     end
 
-    # Delete the key from the store and return the current value
+    # Fetch value with key. Return default if value is nil.
     #
     # @param [Object] key
-    # @return [Object] current value
-    # @param [Hash] options
-    # @api public
-    def delete(key, options = {})
-      deserialize(@store.delete(key_for(key)))
-    end
-
-    # Clear all keys in this store
-    #
+    # @param [Object] value Default value
     # @param [Hash] options
-    # @return [void]
+    # @return [Object] value from store
     # @api public
-    def clear(options = {})
-      @store.clear
-      nil
+    def fetch(key, value = nil, options = {})
+      load(key, options) || (block_given? && yield(key)) || value
     end
 
-    # Fetch value with key. Return default if value is nil.
+    # Fetch value with key. Return nil if the key doesn't exist
     #
     # @param [Object] key
-    # @param [Object] value Default value
-    # @param [Hash] options
-    # @return [Object] value from store
+    # @return [Object] value
     # @api public
-    def fetch(key, value = nil, options = {})
-      self[key] || (block_given? && yield(key)) || value
+    def [](key)
+      load(key)
     end
 
     # Store value with key
@@ -78,40 +35,5 @@ module Juno
     def []=(key, value)
       store(key, value)
     end
-
-    # Explicitly close the store
-    # @api public
-    def close
-      nil
-    end
-
-    protected
-
-    # Serialize value
-    #
-    # @param [Object] value Serializable object
-    # @return [String] serialized object
-    # @api private
-    def serialize(value)
-      Marshal.dump(value)
-    end
-
-    # Deserialize value
-    #
-    # @param [String] value Serialized object
-    # @return [Object] Deserialized object
-    # @api private
-    def deserialize(value)
-      value && Marshal.load(value)
-    end
-
-    # Convert key to string
-    #
-    # @param [Object] key Key
-    # @return [String] Marshalled key
-    # @api private
-    def key_for(key)
-      String === key ? key : Marshal.dump(key)
-    end
   end
 end