juno 0.1.1 → 0.2.0

data/lib/juno/builder.rb

@@ -0,0 +1,30 @@
+module Juno
+  class Builder
+    def build
+      klass, options, block = @proxies.first
+      store = klass.new(@options.merge(options), &block)
+      @proxies[1..-1].each do |proxy|
+        klass, options, block = proxy
+        store = klass.new(store, @options.merge(options), &block)
+      end
+      store
+    end
+
+    def initialize(options = {}, &block)
+      raise 'No block given' unless block_given?
+      raise 'Options must be Hash' unless Hash === options
+      @options = options
+      @proxies = []
+      instance_eval(&block)
+    end
+
+    def use(proxy, options = {}, &block)
+      proxy = Juno.const_get(proxy) if Symbol === proxy
+      @proxies.unshift [proxy, options, block]
+    end
+
+    def adapter(name, options = {}, &block)
+      use(Adapters.const_get(name), options, &block)
+    end
+  end
+end

data/lib/juno/cache.rb

@@ -0,0 +1,64 @@
+module Juno
+  class Cache < Base
+    class DSL
+      def initialize(options, &block)
+        @cache, @backend = options[:cache], options[:backend]
+        instance_eval(&block)
+      end
+
+      def backend(options = {}, &block)
+        raise 'Backend already set' if @backend
+        @backend = Hash === options ? Juno.build(options, &block) : options
+      end
+
+      def cache(options = {}, &block)
+        raise 'Cache already set' if @cache
+        @cache = Hash === options ? Juno.build(options, &block) : options
+      end
+
+      def result
+        [@cache, @backend]
+      end
+    end
+
+    attr_reader :cache, :backend
+
+    def initialize(options = {}, &block)
+      @cache, @backend = DSL.new(options, &block).result
+    end
+
+    def key?(key, options = {})
+      @cache.key?(key, options) || @backend.key?(key, options)
+    end
+
+    def load(key, options = {})
+      value = @cache.load(key, options)
+      unless value
+        value = @backend.load(key, options)
+        @cache.store(key, value, options) if value
+      end
+      value
+    end
+
+    def store(key, value, options = {})
+      @cache.store(key, value, options)
+      @backend.store(key, value, options)
+    end
+
+    def delete(key, options = {})
+      @cache.delete(key, options)
+      @backend.delete(key, options)
+    end
+
+    def clear(options = {})
+      @cache.clear(options)
+      @backend.clear(options)
+      self
+    end
+
+    def close
+      @cache.close
+      @backend.close
+    end
+  end
+end

data/lib/juno/expires.rb

@@ -1,22 +1,18 @@
 module Juno
   class Expires < Proxy
     def key?(key, options = {})
-      !!self[key]
+      !!load(key, options)
     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)
+    def load(key, options = {})
+      value = check_expired(key, super(key, options))
+      if value && options.include?(:expires)
+        store(key, value, options)
       else
-        result
+        value
       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)

data/lib/juno/proxy.rb

@@ -1,5 +1,64 @@
-require 'delegate'
-
 module Juno
-  Proxy = DelegateClass(Base)
+  class Proxy < Base
+    attr_reader :adapter
+
+    def initialize(adapter, options = {})
+      @adapter = adapter
+    end
+
+    # Exists the value with key
+    #
+    # @param [Object] key
+    # @return [Boolean]
+    # @param [Hash] options
+    # @api public
+    def key?(key, options = {})
+      @adapter.key?(key, options)
+    end
+
+    # Fetch value with key. Return nil if the key doesn't exist
+    #
+    # @param [Object] key
+    # @param [Hash] options
+    # @return [Object] value
+    # @api public
+    def load(key, options = {})
+      @adapter.load(key, options)
+    end
+
+    # Store value with key
+    #
+    # @param [Object] key
+    # @param [Object] value
+    # @param [Hash] options
+    # @return value
+    # @api public
+    def store(key, value, options = {})
+      @adapter.store(key, value, options)
+    end
+
+    # Delete the key from the store and return the current value
+    #
+    # @param [Object] key
+    # @return [Object] current value
+    # @param [Hash] options
+    # @api public
+    def delete(key, options = {})
+      @adapter.delete(key, options)
+    end
+
+    # Clear all keys in this store
+    #
+    # @param [Hash] options
+    # @return [void]
+    # @api public
+    def clear(options = {})
+      @adapter.clear(options)
+      self
+    end
+
+    def close
+      @adapter.close
+    end
+  end
 end

data/lib/juno/stack.rb

@@ -1,40 +1,56 @@
 module Juno
   class Stack < Base
-    def initialize(options = {})
-      raise 'No option :stores specified' unless @stores = options[:stores]
+    class DSL
+      attr_reader :stack
+
+      def initialize(options, &block)
+        @stack = options[:stack].to_a
+        instance_eval(&block)
+      end
+
+      def add(options = {}, &block)
+        @stack << (Hash === options ? Juno.build(options, &block) : options)
+        nil
+      end
+    end
+
+    attr_reader :stack
+
+    def initialize(options = {}, &block)
+      @stack = DSL.new(options, &block).stack
     end
 
     def key?(key, options = {})
-      @stores.any? {|s| s.key?(key) }
+      @stack.any? {|s| s.key?(key) }
     end
 
-    def [](key)
-      @stores.each do |s|
-        value = s[key]
+    def load(key, options = {})
+      @stack.each do |s|
+        value = s.load(key, options)
         return value if value
       end
       nil
     end
 
     def store(key, value, options = {})
-      @stores.each {|s| s.store(key, value, options) }
+      @stack.each {|s| s.store(key, value, options) }
       value
     end
 
     def delete(key, options = {})
-      @stores.inject(nil) do |value, s|
+      @stack.inject(nil) do |value, s|
         v = s.delete(key, options)
         value || v
       end
     end
 
     def clear(options = {})
-      @stores.each {|s| s.clear }
-      nil
+      @stack.each {|s| s.clear }
+      self
     end
 
     def close
-      @stores.each {|s| s.close }
+      @stack.each {|s| s.close }
       nil
     end
   end

data/lib/juno/transformer.rb

@@ -0,0 +1,106 @@
+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" },
+      :json    => { :load => '::MultiJson.load(VALUE).first',  :dump => '::MultiJson.dump([VALUE])', :require => 'multi_json' },
+      :yaml    => { :load => '::YAML.load(VALUE)',             :dump => '::YAML.dump(VALUE)',        :require => 'yaml' },
+      #:tnet    => { :load => '::TNetstring.parse(VALUE)',      :dump => '::TNetstring.dump(VALUE)', :require => 'tnetstring' },
+      :msgpack => { :load => '::MessagePack.unpack(VALUE)',    :dump => '::MessagePack.pack(VALUE)', :require => 'msgpack' },
+      :bson    => { :load => '::BSON.deserialize(VALUE)["v"]', :dump => '::BSON.serialize({"v"=>VALUE})',   :require => 'bson' },
+    }
+
+    KEY_TRANSFORMER = {
+      :base64  => { :transform => "[KEY].pack('m').strip" },
+      :spread  => { :transform => '(TMP = KEY; ::File.join(TMP[0..1], TMP[2..-1]))' },
+      :escape  => { :transform => "KEY.gsub(/[^a-zA-Z0-9_-]+/) { '%%' + $&.unpack('H2' * $&.bytesize).join('%%').upcase }" },
+      :md5     => { :transform => '::Digest::MD5.hexdigest(KEY)',                              :require => 'digest/md5' },
+      :json    => { :transform => '(TMP = KEY; String === TMP ? TMP : ::MultiJson.dump(TMP))', :require => 'multi_json' },
+      :bson    => { :transform => '(TMP = KEY; String === TMP ? TMP : ::BSON.serialize({"k"=>TMP}).to_s)', :require => 'bson' },
+      :yaml    => { :transform => '(TMP = KEY; String === TMP ? TMP : ::YAML.dump(TMP))',      :require => 'yaml' },
+      :marshal => { :transform => '(TMP = KEY; String === TMP ? TMP : ::Marshal.dump(TMP))' },
+      #:tnet    => { :transform => '(TMP = KEY; String === TMP ? TMP : ::TNetstring.dump(TMP))', :require => 'tnetstring' },
+      :msgpack => { :transform => '(TMP = KEY; String === TMP ? TMP : ::MessagePack.pack(TMP))', :require => 'msgpack' },
+    }
+
+    class << self
+      def compile(keys, values)
+        tmp, key = 0, 'key'
+        keys.each do |tn|
+          raise "Unknown key transformer #{tn}" unless t = KEY_TRANSFORMER[tn]
+          require t[:require] if t[:require]
+          key = t[:transform].gsub('KEY', key).gsub('TMP', "x#{tmp}")
+          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'
+          klass.class_eval <<-end_eval, __FILE__, __LINE__
+              def key?(key, options = {})
+                @adapter.key?(#{key}, options)
+              end
+
+              def load(key, options = {})
+                @adapter.load(#{key}, options)
+              end
+
+              def store(key, value, options = {})
+                @adapter.store(#{key}, value, options)
+              end
+
+              def delete(key, options = {})
+                @adapter.delete(#{key}, options)
+              end
+            end_eval
+        else
+          klass.class_eval <<-end_eval, __FILE__, __LINE__
+              def key?(key, options = {})
+                @adapter.key?(#{key}, options)
+              end
+
+              def load(key, options = {})
+                value = @adapter.load(#{key}, options)
+                value && #{loader}
+              end
+
+              def store(key, value, options = {})
+                @adapter.store(#{key}, #{dumper}, options)
+                value
+              end
+
+              def delete(key, options = {})
+                value = @adapter.delete(#{key}, options)
+                value && #{loader}
+              end
+            end_eval
+        end
+        klass
+      end
+
+      def new(store, options = {})
+        keys = [options[:key]].flatten.compact
+        values = [options[:value]].flatten.compact
+        klass = @classes["#{keys.join('-')}+#{values.join('-')}"] ||= compile(keys, values)
+        klass.original_new(store, options)
+      end
+    end
+  end
+end

data/lib/juno/version.rb

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

data/lib/juno.rb

@@ -1,31 +1,83 @@
 module Juno
-  autoload :ActiveRecord,    'juno/activerecord'
-  autoload :Base,            'juno/base'
-  autoload :Cassandra,       'juno/cassandra'
-  autoload :Couch,           'juno/couch'
-  autoload :DataMapper,      'juno/datamapper'
-  autoload :DBM,             'juno/dbm'
-  autoload :Expires,         'juno/expires'
-  autoload :File,            'juno/file'
-  autoload :Fog,             'juno/fog'
-  autoload :GDBM,            'juno/gdbm'
-  autoload :HashFile,        'juno/hashfile'
-  autoload :LocalMemCache,   'juno/localmemcache'
-  autoload :Memcached,       'juno/memcached'
-  autoload :MemcachedDalli,  'juno/memcached_dalli'
-  autoload :MemcachedNative, 'juno/memcached_native'
-  autoload :Memory,          'juno/memory'
-  autoload :MongoDB,         'juno/mongodb'
-  autoload :Null,            'juno/null'
-  autoload :Proxy,           'juno/proxy'
-  autoload :PStore,          'juno/pstore'
-  autoload :Redis,           'juno/redis'
-  autoload :Riak,            'juno/riak'
-  autoload :SDBM,            'juno/sdbm'
-  autoload :Sequel,          'juno/sequel'
-  autoload :Stack,           'juno/stack'
-  autoload :Sqlite,          'juno/sqlite'
-  autoload :TokyoCabinet,    'juno/tokyocabinet'
-  #autoload :TokyoTyrant,     'juno/tokyotyrant'
-  autoload :YAML,            'juno/yaml'
+  autoload :Base,              'juno/base'
+  autoload :Builder,           'juno/builder'
+  autoload :Cache,             'juno/cache'
+  autoload :Expires,           'juno/expires'
+  autoload :Proxy,             'juno/proxy'
+  autoload :Stack,             'juno/stack'
+  autoload :Transformer,       'juno/transformer'
+
+  module Adapters
+    autoload :ActiveRecord,    'juno/adapters/activerecord'
+    autoload :Cassandra,       'juno/adapters/cassandra'
+    autoload :Couch,           'juno/adapters/couch'
+    autoload :DataMapper,      'juno/adapters/datamapper'
+    autoload :DBM,             'juno/adapters/dbm'
+    autoload :File,            'juno/adapters/file'
+    autoload :Fog,             'juno/adapters/fog'
+    autoload :GDBM,            'juno/adapters/gdbm'
+    autoload :LocalMemCache,   'juno/adapters/localmemcache'
+    autoload :Memcached,       'juno/adapters/memcached'
+    autoload :MemcachedDalli,  'juno/adapters/memcached_dalli'
+    autoload :MemcachedNative, 'juno/adapters/memcached_native'
+    autoload :Memory,          'juno/adapters/memory'
+    autoload :Mongo,           'juno/adapters/mongo'
+    autoload :Null,            'juno/adapters/null'
+    autoload :PStore,          'juno/adapters/pstore'
+    autoload :Redis,           'juno/adapters/redis'
+    autoload :Riak,            'juno/adapters/riak'
+    autoload :SDBM,            'juno/adapters/sdbm'
+    autoload :Sequel,          'juno/adapters/sequel'
+    autoload :Sqlite,          'juno/adapters/sqlite'
+    autoload :TokyoCabinet,    'juno/adapters/tokyocabinet'
+    autoload :YAML,            'juno/adapters/yaml'
+  end
+
+  def self.new(name, options = {})
+    raise 'Name must be Symbol' unless Symbol === name
+    case name
+    when :Sequel, :ActiveRecord, :Couch
+      # 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
+    when :Memcached, :MemcachedDalli, :MemcachedNative
+      # Memcached accept only base64 keys
+      build(options) do
+        use :Transformer, :key => [:marshal, :base64], :value => :marshal
+        adapter name
+      end
+    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
+    when :HashFile
+      # Use spreading hashes
+      build(options) do
+        use :Transformer, :key => [:marshal, :md5, :spread], :value => :marshal
+        adapter :File
+      end
+    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
+    end
+  end
+
+  def self.build(options = {}, &block)
+    Builder.new(options, &block).build
+  end
 end

data/spec/adapter_activerecord_spec.rb

@@ -0,0 +1,41 @@
+# Generated file
+require 'helper'
+
+begin
+  Juno::Adapters::ActiveRecord.new(:connection => { :adapter => (defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3'), :database => File.join(make_tempdir, 'adapter_activerecord.sqlite3') }).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.clear
+    end
+
+    after do
+      @store.close.should == nil if @store
+    end
+
+    it_should_behave_like 'null_stringkey_stringvalue'
+    it_should_behave_like 'store_stringkey_stringvalue'
+    it_should_behave_like 'returndifferent_stringkey_stringvalue'
+
+    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.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')
+
+      store = Juno::Adapters::ActiveRecord.new
+      store.table.table_exists?.should == true
+    end
+
+  end
+rescue LoadError => ex
+  puts "Test adapter_activerecord not executed: #{ex.message}"
+rescue Exception => ex
+  puts "Test adapter_activerecord not executed: #{ex.message}"
+  #puts "#{ex.backtrace.join("\n")}"
+end

data/spec/adapter_cassandra_spec.rb

@@ -0,0 +1,27 @@
+# Generated file
+require 'helper'
+
+begin
+  Juno::Adapters::Cassandra.new.close
+
+  describe "adapter_cassandra" do
+    before do
+      @store = Juno::Adapters::Cassandra.new
+      @store.clear
+    end
+
+    after do
+      @store.close.should == nil if @store
+    end
+
+    it_should_behave_like 'null_stringkey_stringvalue'
+    it_should_behave_like 'store_stringkey_stringvalue'
+    it_should_behave_like 'returndifferent_stringkey_stringvalue'
+
+  end
+rescue LoadError => ex
+  puts "Test adapter_cassandra not executed: #{ex.message}"
+rescue Exception => ex
+  puts "Test adapter_cassandra not executed: #{ex.message}"
+  #puts "#{ex.backtrace.join("\n")}"
+end

data/spec/adapter_couch_spec.rb

@@ -0,0 +1,27 @@
+# Generated file
+require 'helper'
+
+begin
+  Juno::Adapters::Couch.new(:db => 'adapter_couch').close
+
+  describe "adapter_couch" do
+    before do
+      @store = Juno::Adapters::Couch.new(:db => 'adapter_couch')
+      @store.clear
+    end
+
+    after do
+      @store.close.should == nil if @store
+    end
+
+    it_should_behave_like 'null_stringkey_stringvalue'
+    it_should_behave_like 'store_stringkey_stringvalue'
+    it_should_behave_like 'returndifferent_stringkey_stringvalue'
+
+  end
+rescue LoadError => ex
+  puts "Test adapter_couch not executed: #{ex.message}"
+rescue Exception => ex
+  puts "Test adapter_couch not executed: #{ex.message}"
+  #puts "#{ex.backtrace.join("\n")}"
+end

data/spec/adapter_datamapper_spec.rb

@@ -0,0 +1,61 @@
+# Generated file
+require 'helper'
+
+begin
+  require 'dm-core'
+  DataMapper.setup(:default, :adapter => :in_memory)
+  Juno::Adapters::DataMapper.new(:setup => "sqlite3://#{make_tempdir}/adapter_datamapper.sqlite3").close
+
+  describe "adapter_datamapper" do
+    before do
+      @store = Juno::Adapters::DataMapper.new(:setup => "sqlite3://#{make_tempdir}/adapter_datamapper.sqlite3")
+      @store.clear
+    end
+
+    after do
+      @store.close.should == nil if @store
+    end
+
+    it_should_behave_like 'null_stringkey_stringvalue'
+    it_should_behave_like 'store_stringkey_stringvalue'
+    it_should_behave_like 'returndifferent_stringkey_stringvalue'
+    it_should_behave_like 'returndifferent_stringkey_objectvalue'
+    it_should_behave_like 'null_stringkey_objectvalue'
+    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.clear
+
+      second = Juno::Adapters::DataMapper.new(:repository => :sample, :setup => "sqlite3://#{make_tempdir}/datamapper-second.sqlite3")
+      second.clear
+
+      first['key'] = 'value'
+      second['key'] = 'value2'
+
+      first['key'].should == 'value'
+      second['key'].should == 'value2'
+    end
+
+    it 'does not cross contaminate when deleting' do
+      first = Juno::Adapters::DataMapper.new(:setup => "sqlite3://#{make_tempdir}/datamapper-first.sqlite3")
+      first.clear
+
+      second = Juno::Adapters::DataMapper.new(:repository => :sample, :setup => "sqlite3://#{make_tempdir}/datamapper-second.sqlite3")
+      second.clear
+
+      first['key'] = 'value'
+      second['key'] = 'value2'
+
+      first.delete('key').should == 'value'
+      first.key?('key').should == false
+      second['key'].should == 'value2'
+    end
+
+  end
+rescue LoadError => ex
+  puts "Test adapter_datamapper not executed: #{ex.message}"
+rescue Exception => ex
+  puts "Test adapter_datamapper not executed: #{ex.message}"
+  #puts "#{ex.backtrace.join("\n")}"
+end

data/spec/adapter_dbm_spec.rb

@@ -0,0 +1,27 @@
+# Generated file
+require 'helper'
+
+begin
+  Juno::Adapters::DBM.new(:file => File.join(make_tempdir, "adapter_dbm")).close
+
+  describe "adapter_dbm" do
+    before do
+      @store = Juno::Adapters::DBM.new(:file => File.join(make_tempdir, "adapter_dbm"))
+      @store.clear
+    end
+
+    after do
+      @store.close.should == nil if @store
+    end
+
+    it_should_behave_like 'null_stringkey_stringvalue'
+    it_should_behave_like 'store_stringkey_stringvalue'
+    it_should_behave_like 'returndifferent_stringkey_stringvalue'
+
+  end
+rescue LoadError => ex
+  puts "Test adapter_dbm not executed: #{ex.message}"
+rescue Exception => ex
+  puts "Test adapter_dbm not executed: #{ex.message}"
+  #puts "#{ex.backtrace.join("\n")}"
+end