juno 0.1.1 → 0.2.0

data/lib/juno/fog.rb

@@ -1,48 +0,0 @@
-require 'fog'
-
-module Juno
-  class Fog < Base
-    def initialize(options = {})
-      raise 'No option :dir specified' unless dir = options.delete(:dir)
-      storage = ::Fog::Storage.new(options)
-      @directory = storage.directories.create(:key => dir)
-    end
-
-    def key?(key, options = {})
-      !!@directory.files.head(key_for(key))
-    end
-
-    def [](key)
-      if value = get(key)
-        deserialize(value.body)
-      end
-    end
-
-    def delete(key, options = {})
-      value = get(key)
-      if value
-        body = deserialize(value.body)
-        value.destroy
-        body
-      end
-    end
-
-    def store(key, value, options = {})
-      @directory.files.create(:key => key_for(key), :body => serialize(value))
-      value
-    end
-
-    def clear(options = {})
-      @directory.files.all.each do |file|
-        file.destroy
-      end
-      nil
-    end
-
-    private
-
-    def get(key)
-      @directory.files.get(key_for(key))
-    end
-  end
-end

data/lib/juno/gdbm.rb

@@ -1,15 +0,0 @@
-require 'gdbm'
-
-module Juno
-  class GDBM < Base
-    def initialize(options = {})
-      raise 'No option :file specified' unless options[:file]
-      @store = ::GDBM.new(options[:file])
-    end
-
-    def close
-      @store.close
-      nil
-    end
-  end
-end

data/lib/juno/hashfile.rb

@@ -1,12 +0,0 @@
-require 'digest/md5'
-
-module Juno
-  class HashFile < Juno::File
-    protected
-
-    def store_path(key)
-      hash = Digest::MD5.hexdigest(key_for(key))
-      ::File.join(@dir, hash[0..1], hash[2..-1])
-    end
-  end
-end

data/lib/juno/localmemcache.rb

@@ -1,16 +0,0 @@
-require 'localmemcache'
-
-module Juno
-  class LocalMemCache < Base
-    def initialize(options = {})
-      raise 'No option :file specified' unless options[:file]
-      @store = ::LocalMemCache.new(:filename => options[:file])
-    end
-
-    def delete(key, options = {})
-      value = self[key]
-      @store.delete(key_for(key))
-      value
-    end
-  end
-end

data/lib/juno/memcached.rb

@@ -1,7 +0,0 @@
-module Juno
-  begin
-    Memcached = MemcachedNative
-  rescue LoadError
-    Memcached = MemcachedDalli
-  end
-end

data/lib/juno/memcached_dalli.rb

@@ -1,55 +0,0 @@
-require 'dalli'
-
-module Juno
-  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_for(key))
-    end
-
-    def fetch(key, value = nil, options = {})
-      result = super
-      if result && options.include?(:expires)
-        store(key, result, options)
-      else
-        result
-      end
-    end
-
-    def [](key)
-      deserialize(@cache.get(key_for(key)))
-    end
-
-    def store(key, value, options = {})
-      @cache.set(key_for(key), serialize(value), options[:expires])
-      value
-    end
-
-    def delete(key, options = {})
-      key = key_for(key)
-      value = deserialize(@cache.get(key))
-      @cache.delete(key)
-      value
-    end
-
-    def clear(options = {})
-      @cache.flush_all
-      nil
-    end
-
-    def close
-      @cache.close
-      nil
-    end
-
-    private
-
-    def key_for(key)
-      [super].pack('m').strip
-    end
-  end
-end

data/lib/juno/memcached_native.rb

@@ -1,56 +0,0 @@
-require 'memcached'
-
-module Juno
-  class MemcachedNative < Base
-    def initialize(options = {})
-      server = options.delete(:server) || 'localhost:11211'
-      @cache = ::Memcached.new(server, options)
-    end
-
-    def key?(key, options = {})
-      @cache.get(key_for(key), false)
-      true
-    rescue ::Memcached::NotFound
-      false
-    end
-
-    def fetch(key, value = nil, options = {})
-      result = super
-      if result && options.include?(:expires)
-        store(key, result, options)
-      else
-        result
-      end
-    end
-
-    def [](key)
-      deserialize(@cache.get(key_for(key), false))
-    rescue ::Memcached::NotFound
-    end
-
-    def delete(key, options = {})
-      key = key_for(key)
-      value = deserialize(@cache.get(key, false))
-      @cache.delete(key)
-      value
-    rescue ::Memcached::NotFound
-    end
-
-    def store(key, value, options = {})
-      ttl = options[:expires] || ::Memcached::DEFAULTS[:default_ttl]
-      @cache.set(key_for(key), serialize(value), ttl, false)
-      value
-    end
-
-    def clear(options = {})
-      @cache.flush
-      nil
-    end
-
-    private
-
-    def key_for(key)
-      [super].pack('m').strip
-    end
-  end
-end

data/lib/juno/memory.rb

@@ -1,7 +0,0 @@
-module Juno
-  class Memory < Base
-    def initialize(options = {})
-      @store = {}
-    end
-  end
-end

data/lib/juno/mongodb.rb

@@ -1,43 +0,0 @@
-require 'mongo'
-require 'uri'
-
-module Juno
-  class MongoDB < 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)
-      @store = connection.db(db).collection(collection)
-    end
-
-    def key?(key, options = {})
-      !!self[key]
-    end
-
-    def [](key)
-      value = @store.find_one('_id' => key_for(key))
-      value ? deserialize(value['data']) : nil
-    end
-
-    def delete(key, options = {})
-      value = self[key]
-      @store.remove('_id' => key_for(key)) if value
-      value
-    end
-
-    def store(key, value, options = {})
-      key = key_for(key)
-      @store.update({ '_id' => key },
-                    { '_id' => key, 'data' => serialize(value) },
-                    { :upsert => true })
-      value
-    end
-
-    def clear(options = {})
-      @store.remove
-      nil
-    end
-  end
-end

data/lib/juno/null.rb

@@ -1,23 +0,0 @@
-module Juno
-  class Null < Base
-    def key?(key, options = {})
-      false
-    end
-
-    def [](key)
-      nil
-    end
-
-    def store(key, value, options = {})
-      value
-    end
-
-    def delete(key, options = {})
-      nil
-    end
-
-    def clear(options = {})
-      nil
-    end
-  end
-end

data/lib/juno/pstore.rb

@@ -1,49 +0,0 @@
-require 'pstore'
-
-module Juno
-  class PStore < Base
-    def initialize(options = {})
-      raise 'No option :file specified' unless options[:file]
-      FileUtils.mkpath(::File.dirname(options[:file]))
-      @store = new_store(options)
-    end
-
-    def key?(key, options = {})
-      @store.transaction(true) { @store.root?(key_for(key)) }
-    end
-
-    def [](key)
-      @store.transaction(true) { @store[key_for(key)] }
-    end
-
-    def delete(key, options = {})
-      @store.transaction { @store.delete(key_for(key)) }
-    end
-
-    def store(key, value, options = {})
-      @store.transaction { @store[key_for(key)] = value }
-    end
-
-    def clear(options = {})
-      @store.transaction do
-        @store.roots.each do |key|
-          @store.delete(key)
-        end
-      end
-      nil
-    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

data/lib/juno/redis.rb

@@ -1,46 +0,0 @@
-require 'redis'
-
-module Juno
-  class Redis < Base
-    def initialize(options = {})
-      @store = ::Redis.new(options)
-    end
-
-    def key?(key, options = {})
-      @store.exists(key_for(key))
-    end
-
-    def fetch(key, value = nil, options = {})
-      result = super
-      if result && expires = options[:expires]
-        @store.expire(key_for(key), expires)
-      end
-      result
-    end
-
-    def [](key)
-      deserialize(@store.get(key_for(key)))
-    end
-
-    def delete(key, options = {})
-      string_key = key_for(key)
-      value = self[key]
-      @store.del(string_key) if value
-      value
-    end
-
-    def store(key, value, options = {})
-      key = key_for(key)
-      @store.set(key, serialize(value))
-      if expires = options[:expires]
-        @store.expire(key, expires)
-      end
-      value
-    end
-
-    def clear(options = {})
-      @store.flushdb
-      nil
-    end
-  end
-end

data/lib/juno/riak.rb

@@ -1,45 +0,0 @@
-# Copyright: 2011 TMX Credit
-# Author: Potapov Sergey (aka Blake)
-
-require 'ripple'
-
-module Juno
-  class Riak < Base
-    def initialize(options = {})
-      bucket_name = options.delete(:bucket) || 'juno'
-      client = ::Riak::Client.new(options)
-      @bucket = client.bucket(bucket_name)
-    end
-
-    def key?(key, options = {})
-      !!self[key]
-    end
-
-    def [](key)
-      deserialize(@bucket[key_for(key)].data)
-    rescue ::Riak::HTTPFailedRequest => err
-      nil
-    end
-
-    def delete(key, options = {})
-      value = self[key]
-      @bucket.delete(key_for(key))
-      value
-    end
-
-    def store(key, value, options = {})
-      obj = ::Riak::RObject.new(@bucket, key_for(key))
-      obj.content_type = 'text/plain'
-      obj.data = serialize(value)
-      obj.store
-      value
-    end
-
-    def clear(options = {})
-      @bucket.keys(:reload => true) do |keys|
-        keys.each{|key| @bucket.delete(key) }
-      end
-      nil
-    end
-  end
-end

data/lib/juno/sdbm.rb

@@ -1,15 +0,0 @@
-require 'sdbm'
-
-module Juno
-  class SDBM < Base
-    def initialize(options = {})
-      raise 'No option :file specified' unless options[:file]
-      @store = ::SDBM.new(options[:file])
-    end
-
-    def close
-      @store.close
-      nil
-    end
-  end
-end

data/lib/juno/sequel.rb

@@ -1,48 +0,0 @@
-require 'sequel'
-
-module Juno
-  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
-        blob :k
-        blob :v
-      end
-    end
-
-    def key?(key, options = {})
-      !!sequel_table[:k => key_for(key)]
-    end
-
-    def [](key)
-      result = sequel_table[:k => key_for(key)]
-      result ? deserialize(result[:v]) : nil
-    end
-
-    def store(key, value, options = {})
-      sequel_table.insert(:k => key_for(key), :v => serialize(value))
-      value
-    end
-
-    def delete(key, options = {})
-      if value = self[key]
-        sequel_table.filter(:k => key_for(key)).delete
-        value
-      end
-    end
-
-    def clear(options = {})
-      sequel_table.delete
-      nil
-    end
-
-    private
-
-    def sequel_table
-      @sequel_table ||= @db[@table]
-    end
-  end
-end

data/lib/juno/sqlite.rb

@@ -1,50 +0,0 @@
-require 'sqlite3'
-
-module Juno
-  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_for(key)).empty?
-    end
-
-    def [](key)
-      rows = @select.execute!(key_for(key))
-      rows.empty? ? nil : deserialize(rows.first.first)
-    end
-
-    def store(key, value, options = {})
-      @insert.execute!(key_for(key), serialize(value))
-      value
-    end
-
-    def delete(key, options = {})
-      value = self[key]
-      @delete.execute!(key_for(key))
-      value
-    end
-
-    def clear(options = {})
-      @clear.execute!
-      nil
-    end
-
-    def close
-      @select.close
-      @insert.close
-      @delete.close
-      @clear.close
-      @db.close
-      nil
-    end
-  end
-end

data/lib/juno/tokyocabinet.rb

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

data/lib/juno/yaml.rb

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