juno 0.1.0

data/lib/juno/couch.rb

@@ -0,0 +1,43 @@
+require 'couchrest'
+
+module Juno
+  class Couch < Base
+    def initialize(options = {})
+      @db = ::CouchRest.database!(options[:db])
+    end
+
+    def key?(key, options = {})
+      !!self[key_for(key)]
+    rescue RestClient::ResourceNotFound
+      false
+    end
+
+    def [](key)
+      deserialize(@db.get(key_for(key))['data'])
+    rescue RestClient::ResourceNotFound
+      nil
+    end
+
+    def store(key, value, options = {})
+      @db.save_doc('_id' => key_for(key), :data => serialize(value))
+      value
+    rescue RestClient::RequestFailed
+      value
+    end
+
+    def delete(key, options = {})
+      value = @db.get(key_for(key))
+      if value
+        @db.delete_doc({'_id' => value['_id'], '_rev' => value['_rev']}) if value
+        deserialize(value['data'])
+      end
+    rescue RestClient::ResourceNotFound
+      nil
+    end
+
+    def clear(options = {})
+      @db.recreate!
+      nil
+    end
+  end
+end

data/lib/juno/datamapper.rb

@@ -0,0 +1,63 @@
+require 'dm-core'
+require 'dm-migrations'
+
+module Juno
+  class DataMapper < Base
+    class Store
+      include ::DataMapper::Resource
+      property :k, String, :key => true
+      property :v, Object, :lazy => false
+    end
+
+    def initialize(options = {})
+      raise 'No option :setup specified' unless options[:setup]
+      @repository = options.delete(:repository) || :juno
+      Store.storage_names[@repository] = options.delete(:table) || :juno
+      ::DataMapper.setup(@repository, options[:setup])
+      context { Store.auto_upgrade! }
+    end
+
+    def key?(key, options = {})
+      context { !!Store.get(key_for(key)) }
+    end
+
+    def [](key)
+      context do
+        record = Store.get(key_for(key))
+        record ? record.v : nil
+      end
+    end
+
+    def store(key, value, options = {})
+      key = key_for(key)
+      context do
+        record = Store.get(key)
+        if record
+          record.update(key, value)
+        else
+          Store.create(:k => key, :v => value)
+        end
+      end
+      value
+    end
+
+    def delete(key, options = {})
+      context do
+        value = self[key]
+        Store.all(:k => key_for(key)).destroy!
+        value
+      end
+    end
+
+    def clear(options = {})
+      context { Store.all.destroy! }
+      nil
+    end
+
+    private
+
+    def context
+      ::DataMapper.repository(@repository) { yield }
+    end
+  end
+end

data/lib/juno/dbm.rb

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

data/lib/juno/expires.rb

@@ -0,0 +1,45 @@
+module Juno
+  class Expires < Proxy
+    def key?(key, options = {})
+      !!self[key]
+    end
+
+    def fetch(key, value = nil, options = {}, &block)
+      result = check_expired(key, super(key, value, options, &block))
+      if result && options.include?(:expires)
+        store(key, result, options)
+      else
+        result
+      end
+    end
+
+    def [](key)
+      check_expired(key, super(key))
+    end
+
+    def store(key, value, options = {})
+      if expires = options.delete(:expires)
+        super(key, [value, Time.now.to_i + expires].compact, options)
+      else
+        super(key, [value], options)
+      end
+      value
+    end
+
+    def delete(key, options = {})
+      check_expired(key, super, false)
+    end
+
+    protected
+
+    def check_expired(key, value, delete_expired = true)
+      value, expires = value
+      if expires && Time.now.to_i > expires
+        delete(key) if delete_expired
+        nil
+      else
+        value
+      end
+    end
+  end
+end

data/lib/juno/file.rb

@@ -0,0 +1,62 @@
+require 'fileutils'
+
+module Juno
+  class File < Base
+    def initialize(options = {})
+      raise 'No option :dir specified' unless @dir = options[:dir]
+      FileUtils.mkpath(@dir)
+      raise "#{@dir} is not a dir" unless ::File.directory?(@dir)
+    end
+
+    def key?(key, options = {})
+      ::File.exist?(store_path(key))
+    end
+
+    def [](key)
+      deserialize(::File.read(store_path(key)))
+    rescue Errno::ENOENT
+    end
+
+    def store(key, value, options = {})
+      path = store_path(key)
+      temp_file = ::File.join(@dir, "value-#{$$}-#{Thread.current.object_id}")
+      FileUtils.mkpath(::File.dirname(path))
+      ::File.open(temp_file, 'wb') {|file| file.write(serialize(value)) }
+      ::File.unlink(path) if ::File.exist?(path)
+      ::File.rename(temp_file, path)
+      value
+    rescue Errno::ENOENT
+      ::File.unlink(temp_file) rescue nil
+      value
+    end
+
+    def delete(key, options = {})
+      value = self[key]
+      ::File.unlink(store_path(key))
+      value
+    rescue Errno::ENOENT
+    end
+
+    def clear(options = {})
+      temp_dir = "#{@dir}-#{$$}-#{Thread.current.object_id}"
+      ::File.rename(@dir, temp_dir)
+      FileUtils.mkpath(@dir)
+      FileUtils.rm_rf(temp_dir)
+      nil
+    rescue Errno::ENOENT
+      nil
+    end
+
+    protected
+
+    def escape(s)
+      s.gsub(/[^a-zA-Z0-9_-]+/) do
+        '%' + $&.unpack('H2' * $&.bytesize).join('%').upcase
+      end
+    end
+
+    def store_path(key)
+      ::File.join(@dir, escape(key_for(key)))
+    end
+  end
+end

data/lib/juno/gdbm.rb

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

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

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

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

data/lib/juno/memcached_dalli.rb

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

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

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

data/lib/juno/mongodb.rb

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