juno 0.2.0 → 0.2.1

data/Gemfile

@@ -8,13 +8,13 @@ gem 'parallel_tests'
 
 # Serializer
 #gem 'tnetstring'
-gem 'msgpack'
 gem 'bson'
 gem 'multi_json'
 gem 'json' # Ripple/Riak needs json
 
 # Backends
-gem 'datamapper'
+gem 'dm-core'
+gem 'dm-migrations'
 gem 'dm-sqlite-adapter'
 gem 'fog'
 gem 'activerecord'
@@ -30,6 +30,7 @@ if defined?(JRUBY_VERSION)
   gem 'activerecord-jdbc-adapter'
   gem 'activerecord-jdbcsqlite3-adapter'
 else
+  gem 'msgpack'
   gem 'tokyocabinet'
   gem 'memcached'
   gem 'sqlite3'

data/README.md

@@ -106,6 +106,7 @@ store = Juno.build do
   # Memory backend
   adapter :Memory
 end
+~~~
 
 Expiration
 ----------
@@ -126,10 +127,14 @@ end
 You can add the expires feature to other backends using the Expires proxy:
 
 ~~~ ruby
+# Using the :expires option
+cache = Juno.new(:File, :dir => '...', :expires => true)
+
+# or using the proxy...
 cache = Juno::Expires.new(Juno::Adapters::File.new(:dir => '...'))
 cache.store(key, value, :expires => 10)
 
-# Or using the builder...
+# or using the builder...
 cache = Juno.build do
   use :Expires
   adapter :File, :dir => '...'

data/lib/juno.rb

@@ -34,46 +34,38 @@ module Juno
   end
 
   def self.new(name, options = {})
+    expires = options.delete(:expires)
+    transformer = {:key => :marshal, :value => :marshal}
     raise 'Name must be Symbol' unless Symbol === name
     case name
-    when :Sequel, :ActiveRecord, :Couch
+    when :Sequel, :ActiveRecord, :Couch, :Mongo
       # Sequel accept only base64 keys and values
       # FIXME: ActiveRecord and Couch should work only with :marshal but this
       # raises an error on 1.9
-      build(options) do
-        use :Transformer, :key => [:marshal, :base64], :value => [:marshal, :base64]
-        adapter name
-      end
+      # Mongo accepts only valid UTF-8 strings
+      transformer = {:key => [:marshal, :base64], :value => [:marshal, :base64]}
     when :Memcached, :MemcachedDalli, :MemcachedNative
-      # Memcached accept only base64 keys
-      build(options) do
-        use :Transformer, :key => [:marshal, :base64], :value => :marshal
-        adapter name
-      end
+      # Memcached accept only base64 keys, expires already supported
+      expires = false
+      transformer = {:key => [:marshal, :base64], :value => :marshal}
     when :PStore, :YAML, :DataMapper, :Null
       # For PStore, YAML and DataMapper only the key has to be a string
-      build(options) do
-        use :Transformer, :key => :marshal
-        adapter name
-      end
+      transformer = {:key => :marshal}
     when :HashFile
       # Use spreading hashes
-      build(options) do
-        use :Transformer, :key => [:marshal, :md5, :spread], :value => :marshal
-        adapter :File
-      end
+      transformer = {:key => [:marshal, :md5, :spread], :value => :marshal}
+      name = :File
     when :File
       # Use escaping
-      build(options) do
-        use :Transformer, :key => [:marshal, :escape], :value => :marshal
-        adapter :File
-      end
-    else
-      # For all other stores marshal key and value
-      build(options) do
-        use :Transformer, :key => :marshal, :value => :marshal
-        adapter name
-      end
+      transformer = {:key => [:marshal, :escape], :value => :marshal}
+    when :Cassandra, :Redis
+      # Expires already supported
+      expires = false
+    end
+    build(options) do
+      use :Expires if expires
+      use :Transformer, transformer
+      adapter name
     end
   end
 

data/lib/juno/adapters/activerecord.rb

@@ -17,36 +17,43 @@ module Juno
                                                 c
                                               end
         @table.establish_connection(options[:connection]) if options[:connection]
-        @table.connection.create_table @table.table_name do |t|
-          t.binary 'key', :primary => true
-          t.binary 'value'
-        end unless @table.table_exists?
+        unless @table.table_exists?
+          @table.connection.create_table(@table.table_name) do |t|
+            t.binary :k, :null => false
+            t.binary :v
+          end
+          @table.connection.add_index(@table.table_name, :k, :unique => true)
+        end
       end
 
       def key?(key, options = {})
-        !!@table.find_by_key(key)
+        !!@table.find_by_k(key)
       end
 
       def load(key, options = {})
-        record = @table.find_by_key(key)
-        record ? record.value : nil
+        record = @table.find_by_k(key)
+        record ? record.v : nil
       end
 
       def delete(key, options = {})
-        record = @table.find_by_key(key)
-        if record
-          value = record.value
-          record.destroy
-          value
+        @table.transaction do
+          record = @table.find_by_k(key)
+          if record
+            value = record.v
+            record.destroy
+            value
+          end
         end
       end
 
       def store(key, value, options = {})
-        record = @table.find_by_key(key)
-        record ||= @table.new(:key => key)
-        record.value = value
-        record.save!
-        value
+        @table.transaction do
+          record = @table.find_by_k(key)
+          record ||= @table.new(:k => key)
+          record.v = value
+          record.save!
+          value
+        end
       end
 
       def clear(options = {})

data/lib/juno/adapters/couch.rb

@@ -20,7 +20,12 @@ module Juno
       end
 
       def store(key, value, options = {})
-        @db.save_doc('_id' => key, 'data' => value)
+        doc = {'_id' => key, 'data' => value}
+        begin
+          doc['_rev'] = @db.get(key)['_rev']
+        rescue RestClient::ResourceNotFound
+        end
+        @db.save_doc(doc)
         value
       rescue RestClient::RequestFailed
         value

data/lib/juno/adapters/datamapper.rb

@@ -33,19 +33,21 @@ module Juno
         context do
           record = Store.get(key)
           if record
-            record.update(key, value)
+            record.update(:k => key, :v => value)
           else
             Store.create(:k => key, :v => value)
           end
+          value
         end
-        value
       end
 
       def delete(key, options = {})
         context do
-          value = load(key, options)
-          Store.all(:k => key).destroy!
-          value
+          if record = Store.get(key)
+            value = record.v
+            record.destroy!
+            value
+          end
         end
       end
 

data/lib/juno/adapters/sequel.rb

@@ -8,8 +8,7 @@ module Juno
         @table = options.delete(:table) || :juno
         @db = ::Sequel.connect(db, options)
         @db.create_table?(@table) do
-          primary_key :k
-          String :k
+          String :k, :null => false, :primary_key => true
           String :v
         end
       end
@@ -24,14 +23,22 @@ module Juno
       end
 
       def store(key, value, options = {})
-        sequel_table.insert(:k => key, :v => value)
-        value
+        @db.transaction do
+          if key?(key, options)
+            sequel_table.update(:k => key, :v => value)
+          else
+            sequel_table.insert(:k => key, :v => value)
+          end
+          value
+        end
       end
 
       def delete(key, options = {})
-        if value = load(key, options)
-          sequel_table.filter(:k => key).delete
-          value
+        @db.transaction do
+          if value = load(key, options)
+            sequel_table.filter(:k => key).delete
+            value
+          end
         end
       end
 

data/lib/juno/adapters/sqlite.rb

@@ -7,10 +7,10 @@ module Juno
         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 = ?")
+        @db.execute("create table if not exists #{table} (k blob not null primary key, v blob)")
+        @select = @db.prepare("select v from #{table} where k = ?")
+        @insert = @db.prepare("insert or replace into #{table} values (?, ?)")
+        @delete = @db.prepare("delete from #{table} where k = ?")
         @clear = @db.prepare("delete from #{table}")
       end
 

data/lib/juno/transformer.rb

@@ -1,11 +1,5 @@
 module Juno
   class Transformer < Proxy
-    @classes = {}
-
-    class << self
-      alias_method :original_new, :new
-    end
-
     VALUE_TRANSFORMER = {
       :marshal => { :load => '::Marshal.load(VALUE)',          :dump => '::Marshal.dump(VALUE)' },
       :base64  => { :load => "VALUE.unpack('m').first",        :dump => "[VALUE].pack('m').strip" },
@@ -29,7 +23,11 @@ module Juno
       :msgpack => { :transform => '(TMP = KEY; String === TMP ? TMP : ::MessagePack.pack(TMP))', :require => 'msgpack' },
     }
 
+    @classes = {}
+
     class << self
+      alias_method :original_new, :new
+
       def compile(keys, values)
         tmp, key = 0, 'key'
         keys.each do |tn|
@@ -39,20 +37,8 @@ module Juno
           tmp += 1
         end
 
-        dumper = 'value'
-        values.each do |tn|
-          raise "Unknown value transformer #{tn}" unless t = VALUE_TRANSFORMER[tn]
-          require t[:require] if t[:require]
-          dumper = t[:dump].gsub('VALUE', dumper)
-        end
-
-        loader = 'value'
-        values.reverse.each do |t|
-          loader = VALUE_TRANSFORMER[t][:load].gsub('VALUE', loader)
-        end
-
         klass = Class.new(Transformer)
-        if loader == 'value'
+        if values.empty?
           klass.class_eval <<-end_eval, __FILE__, __LINE__
               def key?(key, options = {})
                 @adapter.key?(#{key}, options)
@@ -71,6 +57,14 @@ module Juno
               end
             end_eval
         else
+          dumper, loader = 'value', 'value'
+          values.each_index do |i|
+            raise "Unknown value transformer #{values[i]}" unless t = VALUE_TRANSFORMER[values[i]]
+            require t[:require] if t[:require]
+            dumper = t[:dump].gsub('VALUE', dumper)
+            loader = VALUE_TRANSFORMER[values[-i-1]][:load].gsub('VALUE', loader)
+          end
+
           klass.class_eval <<-end_eval, __FILE__, __LINE__
               def key?(key, options = {})
                 @adapter.key?(#{key}, options)
@@ -98,6 +92,7 @@ module Juno
       def new(store, options = {})
         keys = [options[:key]].flatten.compact
         values = [options[:value]].flatten.compact
+        raise 'No option :key or :value specified' if keys.empty? && values.empty?
         klass = @classes["#{keys.join('-')}+#{values.join('-')}"] ||= compile(keys, values)
         klass.original_new(store, options)
       end

data/lib/juno/version.rb

@@ -1,3 +1,3 @@
 module Juno
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
 end

data/spec/adapter_activerecord_spec.rb

@@ -2,11 +2,11 @@
 require 'helper'
 
 begin
-  Juno::Adapters::ActiveRecord.new(:connection => { :adapter => (defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3'), :database => File.join(make_tempdir, 'adapter_activerecord.sqlite3') }).close
+  Juno::Adapters::ActiveRecord.new(:connection => { :adapter => (defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3'), :database => File.join(make_tempdir, 'adapter_activerecord') }).close
 
   describe "adapter_activerecord" do
     before do
-      @store = Juno::Adapters::ActiveRecord.new(:connection => { :adapter => (defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3'), :database => File.join(make_tempdir, 'adapter_activerecord.sqlite3') })
+      @store = Juno::Adapters::ActiveRecord.new(:connection => { :adapter => (defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3'), :database => File.join(make_tempdir, 'adapter_activerecord') })
       @store.clear
     end
 
@@ -21,12 +21,12 @@ begin
     it 'updates an existing key/value' do
       @store['foo/bar'] = '1'
       @store['foo/bar'] = '2'
-      records = @store.table.find :all, :conditions => { :key => 'foo/bar' }
+      records = @store.table.find :all, :conditions => { :k => 'foo/bar' }
       records.count.should == 1
     end
 
     it 'uses an existing connection' do
-      ActiveRecord::Base.establish_connection :adapter => (defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3'), :database => File.join(make_tempdir, 'activerecord-existing.sqlite3')
+      ActiveRecord::Base.establish_connection :adapter => (defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3'), :database => File.join(make_tempdir, 'activerecord-existing')
 
       store = Juno::Adapters::ActiveRecord.new
       store.table.table_exists?.should == true

data/spec/adapter_datamapper_spec.rb

@@ -4,11 +4,11 @@ require 'helper'
 begin
   require 'dm-core'
   DataMapper.setup(:default, :adapter => :in_memory)
-  Juno::Adapters::DataMapper.new(:setup => "sqlite3://#{make_tempdir}/adapter_datamapper.sqlite3").close
+  Juno::Adapters::DataMapper.new(:setup => "sqlite3://#{make_tempdir}/adapter_datamapper").close
 
   describe "adapter_datamapper" do
     before do
-      @store = Juno::Adapters::DataMapper.new(:setup => "sqlite3://#{make_tempdir}/adapter_datamapper.sqlite3")
+      @store = Juno::Adapters::DataMapper.new(:setup => "sqlite3://#{make_tempdir}/adapter_datamapper")
       @store.clear
     end
 
@@ -24,10 +24,10 @@ begin
     it_should_behave_like 'store_stringkey_objectvalue'
 
     it 'does not cross contaminate when storing' do
-      first = Juno::Adapters::DataMapper.new(:setup => "sqlite3://#{make_tempdir}/datamapper-first.sqlite3")
+      first = Juno::Adapters::DataMapper.new(:setup => "sqlite3://#{make_tempdir}/datamapper-first")
       first.clear
 
-      second = Juno::Adapters::DataMapper.new(:repository => :sample, :setup => "sqlite3://#{make_tempdir}/datamapper-second.sqlite3")
+      second = Juno::Adapters::DataMapper.new(:repository => :sample, :setup => "sqlite3://#{make_tempdir}/datamapper-second")
       second.clear
 
       first['key'] = 'value'
@@ -38,10 +38,10 @@ begin
     end
 
     it 'does not cross contaminate when deleting' do
-      first = Juno::Adapters::DataMapper.new(:setup => "sqlite3://#{make_tempdir}/datamapper-first.sqlite3")
+      first = Juno::Adapters::DataMapper.new(:setup => "sqlite3://#{make_tempdir}/datamapper-first")
       first.clear
 
-      second = Juno::Adapters::DataMapper.new(:repository => :sample, :setup => "sqlite3://#{make_tempdir}/datamapper-second.sqlite3")
+      second = Juno::Adapters::DataMapper.new(:repository => :sample, :setup => "sqlite3://#{make_tempdir}/datamapper-second")
       second.clear
 
       first['key'] = 'value'

data/spec/adapter_sequel_spec.rb

@@ -2,11 +2,11 @@
 require 'helper'
 
 begin
-  Juno::Adapters::Sequel.new(:db => (defined?(JRUBY_VERSION) ? 'jdbc:sqlite:/' : 'sqlite:/')).close
+  Juno::Adapters::Sequel.new(:db => (defined?(JRUBY_VERSION) ? "jdbc:sqlite:" : "sqlite:") + File.join(make_tempdir, "adapter_sequel")).close
 
   describe "adapter_sequel" do
     before do
-      @store = Juno::Adapters::Sequel.new(:db => (defined?(JRUBY_VERSION) ? 'jdbc:sqlite:/' : 'sqlite:/'))
+      @store = Juno::Adapters::Sequel.new(:db => (defined?(JRUBY_VERSION) ? "jdbc:sqlite:" : "sqlite:") + File.join(make_tempdir, "adapter_sequel"))
       @store.clear
     end
 

data/spec/adapter_sqlite_spec.rb

@@ -2,11 +2,11 @@
 require 'helper'
 
 begin
-  Juno::Adapters::Sqlite.new(:file => ":memory:").close
+  Juno::Adapters::Sqlite.new(:file => File.join(make_tempdir, "adapter_sqlite")).close
 
   describe "adapter_sqlite" do
     before do
-      @store = Juno::Adapters::Sqlite.new(:file => ":memory:")
+      @store = Juno::Adapters::Sqlite.new(:file => File.join(make_tempdir, "adapter_sqlite"))
       @store.clear
     end