juno 0.1.0 → 0.1.1

data/lib/juno/sequel.rb

@@ -6,13 +6,10 @@ module Juno
       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
+      @db.create_table?(@table) do
         primary_key :k
-        String :k
-        String :v
+        blob :k
+        blob :v
       end
     end
 

data/lib/juno/stack.rb

@@ -0,0 +1,41 @@
+module Juno
+  class Stack < Base
+    def initialize(options = {})
+      raise 'No option :stores specified' unless @stores = options[:stores]
+    end
+
+    def key?(key, options = {})
+      @stores.any? {|s| s.key?(key) }
+    end
+
+    def [](key)
+      @stores.each do |s|
+        value = s[key]
+        return value if value
+      end
+      nil
+    end
+
+    def store(key, value, options = {})
+      @stores.each {|s| s.store(key, value, options) }
+      value
+    end
+
+    def delete(key, options = {})
+      @stores.inject(nil) do |value, s|
+        v = s.delete(key, options)
+        value || v
+      end
+    end
+
+    def clear(options = {})
+      @stores.each {|s| s.clear }
+      nil
+    end
+
+    def close
+      @stores.each {|s| s.close }
+      nil
+    end
+  end
+end

data/lib/juno/version.rb

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

data/test/helper.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 require 'minitest/autorun'
 require 'juno'
 require 'fileutils'
@@ -10,173 +11,202 @@ module Helper
   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 = {
+module Juno
+  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
+  NullSpecification = proc do
+    include Helper
 
-    it "writes String values to keys that are #{type}s like a Hash" do
-      @store[key] = 'value'
-      @store[key].must_equal 'value'
+    before do
+      @store = new_store
+      @store.clear
     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)
+    after do
+      @store.close.must_equal nil if @store
     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
+    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 "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 "guarantees that the same String value is returned when setting a #{type} key" do
+        value = 'value'
+        (@store[key] = value).must_be_same_as value
+      end
 
-    it "returns false from key? if a #{type} key is not available" do
-      @store.key?(key).must_equal false
-    end
+      it "guarantees that the same Object value is returned when setting a #{type} key" do
+        value = {:foo => :bar}
+        (@store[key] = value).must_be_same_as value
+      end
 
-    it "returns true from key? if a #{type} key is available" do
-      @store[key] = 'value'
-      @store.key?(key).must_equal true
-    end
+      it "returns false from key? if a #{type} key is not available" do
+        @store.key?(key).must_equal false
+      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 "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 "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 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 "fetches a #{type} key with a block with fetch, if the key is not available" do
-      @store.fetch(key) { |k| 'value' }.must_equal 'value'
+      it 'must accept options' do
+        @store.key?(key, :foo => 42).must_equal false
+        @store.fetch(key, nil, :foo => 42).must_equal nil
+        @store.delete(key, :foo => 42).must_equal nil
+        @store.clear(:foo => 42).must_equal nil
+        @store.store(key, 'value', :foo => 42).must_equal 'value'
+      end
     end
+  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
+  Specification = proc do
+    class_eval(&NullSpecification)
+
+    TYPES.each do |type, (key, key2)|
+      it "writes String values to keys that are #{type}s like a Hash" do
+        @store[key] = 'value'
+        @store[key].must_equal 'value'
+      end
+
+      it "writes Object values to keys that are #{type}s like a Hash" do
+        value = {:foo => :bar}
+        @store[key] = value
+        @store[key].must_equal(:foo => :bar)
+      end
+
+      it "guarantees that a different String value is retrieved from the #{type} key" do
+        value = 'value'
+        @store[key] = value
+        @store[key].wont_be_same_as(value)
+      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 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 "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'
+      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
     end
 
-    it "stores #{key} values with #store" do
-      @store.store(key, 'value').must_equal 'value'
-      @store[key].must_equal 'value'
+    def marshal_error
+      # HACK: Marshalling structs in rubinius without class name throws
+      # NoMethodError (to_sym). TODO: Create an issue for rubinius!
+      if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+        RUBY_VERSION < '1.9' ? ArgumentError : NoMethodError
+      else
+        TypeError
+      end
     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
+    it "refuses to #[] from keys that cannot be marshalled" do
+      lambda do
+        @store[Struct.new(:foo).new(:bar)]
+      end.must_raise(marshal_error)
     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(marshal_error)
+    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(marshal_error)
+    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(marshal_error)
+    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(marshal_error)
+    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)
+    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(marshal_error)
+    end
   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
+  ExpiresSpecification = proc do
+    class_eval(&Specification)
 
-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 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 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)
+    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
+end

data/test/{test_active_record.rb → test_activerecord.rb}

@@ -4,12 +4,10 @@ begin
   describe Juno::ActiveRecord do
     describe 'with connection option set' do
       def new_store
-        store = Juno::ActiveRecord.new(:connection => { :adapter  => 'sqlite3', :database => File.join(make_tempdir, 'db.sqlite3')})
-        store.migrate
-        store
+        Juno::ActiveRecord.new(:connection => { :adapter  => 'sqlite3', :database => File.join(make_tempdir, 'db.sqlite3')})
       end
 
-      class_eval(&JunoSpecification)
+      class_eval(&Juno::Specification)
 
       it 'updates an existing key/value' do
         @store['foo/bar'] = 4
@@ -26,7 +24,6 @@ begin
         ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => File.join(make_tempdir, 'db.sqlite3')
 
         store = Juno::ActiveRecord.new
-        store.migrate
         store.table.table_exists?.must_equal true
       end
     end

data/{unsupported → test}/test_cassandra.rb

@@ -6,7 +6,7 @@ begin
       Juno::Cassandra.new
     end
 
-    class_eval(&JunoSpecification)
+    class_eval(&Juno::ExpiresSpecification)
   end
 rescue LoadError => ex
   puts "Juno::Cassandra not tested: #{ex.message}"

data/test/test_couch.rb

@@ -6,7 +6,7 @@ begin
       Juno::Couch.new :db => 'juno'
     end
 
-    class_eval(&JunoSpecification)
+    class_eval(&Juno::Specification)
   end
 rescue LoadError => ex
   puts "Juno::Couch not tested: #{ex.message}"

data/test/test_datamapper.rb

@@ -15,7 +15,7 @@ begin
         Juno::DataMapper::Store.auto_migrate!(:juno)
       end
 
-      class_eval(&JunoSpecification)
+      class_eval(&Juno::Specification)
     end
 
     describe 'when :repository specified' do
@@ -27,7 +27,7 @@ begin
         Juno::DataMapper::Store.auto_migrate!(:sample)
       end
 
-      class_eval(&JunoSpecification)
+      class_eval(&Juno::Specification)
     end
 
     describe 'with multiple stores' do