juno 0.1.0

data/lib/juno/proxy.rb

@@ -0,0 +1,5 @@
+require 'delegate'
+
+module Juno
+  Proxy = DelegateClass(Base)
+end

data/lib/juno/pstore.rb

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

@@ -0,0 +1,34 @@
+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 [](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 = {})
+      @store.set(key_for(key), serialize(value))
+      value
+    end
+
+    def clear(options = {})
+      @store.flushdb
+      nil
+    end
+  end
+end

data/lib/juno/riak.rb

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

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

@@ -0,0 +1,51 @@
+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)
+    end
+
+    def migrate
+      @db.create_table @table do
+        primary_key :k
+        String :k
+        String :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

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

@@ -0,0 +1,36 @@
+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/version.rb

@@ -0,0 +1,3 @@
+module Juno
+  VERSION = '0.1.0'
+end

data/lib/juno/yaml.rb

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

data/test/helper.rb

@@ -0,0 +1,182 @@
+require 'minitest/autorun'
+require 'juno'
+require 'fileutils'
+
+module Helper
+  def make_tempdir
+    tmp = File.join(File.dirname(__FILE__), 'tmp')
+    FileUtils.mkpath(tmp)
+    tmp
+  end
+end
+
+JunoSpecification = proc do
+  include Helper
+
+  before do
+    @store = new_store
+    @store.clear
+  end
+
+  after do
+    @store.close.must_equal nil if @store
+  end
+
+  types = {
+    'String' => ['key', 'key2'],
+    'Object' => [{:foo => :bar}, {:bar => :baz}]
+  }
+
+  types.each do |type, (key, key2)|
+    it "reads from keys that are #{type}s like a Hash" do
+      @store[key].must_equal nil
+    end
+
+    it "writes String values to keys that are #{type}s like a Hash" do
+      @store[key] = 'value'
+      @store[key].must_equal 'value'
+    end
+
+    it "guarantees that a different String value is retrieved from the #{type} key" do
+      value = 'value'
+      (@store[key] = value).must_be_same_as value
+      @store[key].wont_be_same_as(value)
+    end
+
+    it "writes Object values to keys that are #{type}s like a Hash" do
+      value = {:foo => :bar}
+      (@store[key] = value).must_be_same_as value
+      @store[key].must_equal(:foo => :bar)
+    end
+
+    it "guarantees that a different Object value is retrieved from the #{type} key" do
+      value = {:foo => :bar}
+      @store[key] = value
+      @store[key].wont_be_same_as(:foo => :bar)
+    end
+
+    it "returns false from key? if a #{type} key is not available" do
+      @store.key?(key).must_equal false
+    end
+
+    it "returns true from key? if a #{type} key is available" do
+      @store[key] = 'value'
+      @store.key?(key).must_equal true
+    end
+
+    it "removes and returns an element with a #{type} key from the backing store via delete if it exists" do
+      @store[key] = 'value'
+      @store.delete(key).must_equal 'value'
+      @store.key?(key).must_equal false
+    end
+
+    it "returns nil from delete if an element for a #{type} key does not exist" do
+      @store.delete(key).must_equal nil
+    end
+
+    it "removes all #{type} keys from the store with clear" do
+      @store[key] = 'value'
+      @store[key2] = 'value2'
+      @store.clear.must_equal nil
+      @store.key?(key).wont_equal true
+      @store.key?(key2).wont_equal true
+    end
+
+    it "fetches a #{type} key with a default value with fetch, if the key is not available" do
+      @store.fetch(key, 'value').must_equal 'value'
+    end
+
+    it "fetches a #{type} key with a block with fetch, if the key is not available" do
+      @store.fetch(key) { |k| 'value' }.must_equal 'value'
+    end
+
+    it "does not run the block if the #{type} key is available" do
+      @store[key] = 'value'
+      unaltered = "unaltered"
+      @store.fetch(key) { unaltered = "altered" }
+      unaltered.must_equal "unaltered"
+    end
+
+    it "fetches a #{type} key with a default value with fetch, if the key is available" do
+      @store[key] = 'value2'
+      @store.fetch(key, 'value').must_equal 'value2'
+    end
+
+    it "stores #{key} values with #store" do
+      @store.store(key, 'value').must_equal 'value'
+      @store[key].must_equal 'value'
+    end
+
+    it 'must accept options' do
+      @store.store(key, 'value', :foo => 42).must_equal 'value'
+      @store.key?(key, :foo => 42).must_equal true
+      @store.fetch(key, nil, :foo => 42).must_equal 'value'
+      @store.delete(key, :foo => 42).must_equal 'value'
+      @store.key?(key, :foo => 42).must_equal false
+      @store.clear(:foo => 42).must_equal nil
+    end
+  end
+
+  it "refuses to #[] from keys that cannot be marshalled" do
+    lambda do
+      @store[Struct.new(:foo).new(:bar)]
+    end.must_raise(TypeError)
+  end
+
+  it "refuses to fetch from keys that cannot be marshalled" do
+    lambda do
+      @store.fetch(Struct.new(:foo).new(:bar), true)
+    end.must_raise(TypeError)
+  end
+
+  it "refuses to #[]= to keys that cannot be marshalled" do
+    lambda do
+      @store[Struct.new(:foo).new(:bar)] = 'value'
+    end.must_raise(TypeError)
+  end
+
+  it "refuses to store to keys that cannot be marshalled" do
+    lambda do
+      @store.store Struct.new(:foo).new(:bar), 'value'
+    end.must_raise(TypeError)
+  end
+
+  it "refuses to check for key? if the key cannot be marshalled" do
+    lambda do
+      @store.key? Struct.new(:foo).new(:bar)
+    end.must_raise(TypeError)
+  end
+
+  it "refuses to delete a key if the key cannot be marshalled" do
+    lambda do
+      @store.delete Struct.new(:foo).new(:bar)
+    end.must_raise(TypeError)
+  end
+end
+
+JunoExpiresSpecification = proc do
+  it 'should support expires on store' do
+    @store.store('key', 'value', :expires => 2)
+    @store['key'].must_equal 'value'
+    sleep 3
+    @store['key'].must_equal nil
+  end
+
+  it 'should support updating the expiration time in fetch' do
+    @store.store('key2', 'value2', :expires => 2)
+    @store['key2'].must_equal 'value2'
+    sleep 1
+    @store.fetch('key2', nil, :expires => 3).must_equal 'value2'
+    sleep 1
+    @store['key2'].must_equal 'value2'
+    sleep 3
+    @store['key2'].must_equal nil
+  end
+
+  it 'should respect expires in delete' do
+    @store.store('key', 'value', :expires => 2)
+    @store['key'].must_equal 'value'
+    sleep 3
+    @store.delete('key').must_equal nil
+  end
+end