juno 0.3.1 → 0.4.0

data/lib/juno/adapters/leveldb.rb

@@ -1,35 +0,0 @@
-require 'leveldb'
-
-module Juno
-  module Adapters
-    # LevelDB backend
-    # @api public
-    class LevelDB < Memory
-      # Constructor
-      #
-      # @param [Hash] options
-      #
-      # Options:
-      # * :dir - Database path
-      # * All other options passed to LevelDB::DB#new
-      def initialize(options = {})
-        raise ArgumentError, 'Option :dir is required' unless options[:dir]
-        @memory = ::LevelDB::DB.new(options[:dir])
-      end
-
-      def key?(key, options = {})
-        @memory.includes?(key)
-      end
-
-      def clear(options = {})
-        @memory.each {|k,v| delete(k, options) }
-        self
-      end
-
-      def close
-        @memory.close
-        nil
-      end
-    end
-  end
-end

data/lib/juno/adapters/localmemcache.rb

@@ -1,26 +0,0 @@
-require 'localmemcache'
-
-module Juno
-  module Adapters
-    # LocalMemCache backend
-    # @api public
-    class LocalMemCache < Memory
-      # Constructor
-      #
-      # @param [Hash] options
-      #
-      # Options:
-      # * :file - Database file
-      def initialize(options = {})
-        raise ArgumentError, 'Option :file is required' 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/lruhash.rb

@@ -1,83 +0,0 @@
-module Juno
-  module Adapters
-    # LRUHash backend
-    #
-    # Based on Hashery::LRUHash but simpler and measures memory usage instead of hash size.
-    #
-    # @api public
-    class LRUHash < Base
-      # Constructor
-      #
-      # @param [Hash] options
-      #
-      # Options:
-      # * :max_size - Maximum byte size of hash values (default 1024000)
-      def initialize(options = {})
-        @max_size = options[:max_size] || 1024000
-        clear
-      end
-
-      def key?(key, options = {})
-        @entry.key?(key)
-      end
-
-      def load(key, options = {})
-        if entry = @entry[key]
-          entry.insert_after(@list)
-          entry.value
-        end
-      end
-
-      def store(key, value, options = {})
-        if entry = @entry[key]
-          @size -= entry.value.bytesize
-        else
-          @entry[key] = entry = Entry.new
-          entry.key = key
-        end
-        entry.value = value
-        @size += entry.value.bytesize
-        entry.insert_after(@list)
-        delete(@list.prev.key) while @list.next != @list.prev && @size > @max_size
-        value
-      end
-
-      def delete(key, options = {})
-        if entry = @entry.delete(key)
-          @size -= entry.value.bytesize
-          entry.unlink
-          entry.value
-        end
-      end
-
-      def clear(options = {})
-        @entry, @size = {}, 0
-        @list = Entry.new
-        @list.prev = @list.next = @list
-        self
-      end
-
-      private
-
-      class Entry
-        attr_accessor :key, :value, :prev, :next
-
-        def unlink
-          @prev.next = @next if @prev
-          @next.prev = @prev if @next
-          @prev = @next = nil
-        end
-
-        def insert_after(entry)
-          if entry.next != self
-            unlink
-            @next = entry.next
-            @prev = entry
-            entry.next.prev = self
-            entry.next = self
-          end
-        end
-      end
-    end
-  end
-end

data/lib/juno/adapters/memcached.rb

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

@@ -1,51 +0,0 @@
-require 'dalli'
-
-module Juno
-  module Adapters
-    # Memcached backend (using gem dalli)
-    # @api public
-    class MemcachedDalli < Base
-      # Constructor
-      #
-      # @param [Hash] options
-      #
-      # Options:
-      # * :server - Memcached server (default localhost:11211)
-      # * Other options passed to Dalli::Client#new
-      def initialize(options = {})
-        server = options.delete(:server) || 'localhost:11211'
-        @cache = ::Dalli::Client.new(server, options)
-      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

@@ -1,52 +0,0 @@
-require 'memcached'
-
-module Juno
-  module Adapters
-    # Memcached backend (using gem memcached)
-    # @api public
-    class MemcachedNative < Base
-      # Constructor
-      #
-      # @param [Hash] options
-      #
-      # Options:
-      # * :server - Memcached server (default localhost:11211)
-      # * :namespace - Key namespace
-      # * Other options passed to Memcached#new
-      def initialize(options = {})
-        server = options.delete(:server) || 'localhost:11211'
-        options.merge!(:prefix_key => options.delete(:namespace)) if options[:namespace]
-        @default_ttl = options[:default_ttl] || 604800
-        @cache = ::Memcached.new(server, options)
-      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 = {})
-        # TTL must be Fixnum
-        @cache.set(key, value, options[:expires] || @default_ttl, false)
-        value
-      end
-
-      def clear(options = {})
-        @cache.flush
-        self
-      end
-    end
-  end
-end

data/lib/juno/adapters/memory.rb

@@ -1,32 +0,0 @@
-module Juno
-  module Adapters
-    # Memory backend using a hash to store the entries
-    # @api public
-    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

@@ -1,50 +0,0 @@
-require 'mongo'
-
-module Juno
-  module Adapters
-    # MongoDB backend
-    # @api public
-    class Mongo < Base
-      # Constructor
-      #
-      # @param [Hash] options
-      #
-      # Options:
-      # * :collection - MongoDB collection name (default juno)
-      # * :host - MongoDB server host (default localhost)
-      # * :port - MongoDB server port (default mongodb default port)
-      # * :db - MongoDB database (default juno)
-      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 load(key, options = {})
-        value = @collection.find_one('_id' => key)
-        value ? value['value'].to_s : 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, 'value' => ::BSON::Binary.new(value) },
-                           { :upsert => true })
-        value
-      end
-
-      def clear(options = {})
-        @collection.remove
-        self
-      end
-    end
-  end
-end

data/lib/juno/adapters/null.rb

@@ -1,30 +0,0 @@
-module Juno
-  module Adapters
-    # Null backend which doesn't store anything
-    # @api public
-    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

@@ -1,58 +0,0 @@
-require 'pstore'
-
-module Juno
-  module Adapters
-    # PStore backend
-    # @api public
-    class PStore < Base
-      # Constructor
-      #
-      # @param [Hash] options
-      #
-      # Options:
-      # * :file - PStore file
-      def initialize(options = {})
-        raise ArgumentError, 'Option :file is required' 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)
-          ::PStore.new(options[:file], options[:threadsafe])
-        end
-      else
-        def new_store(options)
-          ::PStore.new(options[:file])
-        end
-      end
-    end
-  end
-end

data/lib/juno/adapters/redis.rb

@@ -1,56 +0,0 @@
-require 'redis'
-
-module Juno
-  module Adapters
-    # Redis backend
-    # @api public
-    class Redis < Base
-      # Constructor
-      #
-      # @param [Hash] options passed to Redis#new
-      def initialize(options = {})
-        @redis = ::Redis.new(options)
-      end
-
-      def key?(key, options = {})
-        if @redis.exists(key)
-          if expires = options[:expires]
-            @redis.expire(key, expires)
-          end
-          true
-        else
-          false
-        end
-      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 = {})
-        if expires = options[:expires]
-          @redis.setex(key, expires, value)
-        else
-          @redis.set(key, value)
-        end
-        value
-      end
-
-      def clear(options = {})
-        @redis.flushdb
-        self
-      end
-    end
-  end
-end