juno 0.2.5 → 0.2.6

data/.travis.yml

@@ -13,7 +13,7 @@ services:
   - memcached
   - mongodb
 before_install:
-  - sudo apt-get install -qq libtokyocabinet8 libtokyocabinet-dev # tokyotyrant
+  - sudo apt-get install -qq libtokyocabinet8 libtokyocabinet-dev liblzo2-dev
 env:
   - "TASK=test:parallel"
   - "TASK=test:non_parallel"
@@ -23,4 +23,8 @@ matrix:
     - rvm: jruby
     - rvm: rbx-18mode
     - rvm: rbx-19mode
+  # Parallel tests do not work on jruby
+  exclude:
+    - rvm: jruby
+      env: "TASK=test:parallel"
 script: "bundle exec rake $TASK"

data/Gemfile

@@ -1,17 +1,33 @@
 source :rubygems
 gemspec
 
+def alternatives(gems)
+  if defined?(JRUBY_VERSION)
+    [gems[:jruby]].flatten.compact.each {|g| gem g }
+  else
+    [gems[:mri]].flatten.compact.each {|g| gem g }
+  end
+end
+
 # Testing
 gem 'rake'
 gem 'rspec'
 gem 'parallel_tests'
 
-# Serializer
+# Serializer used by Transformer
 gem 'tnetstring'
-gem 'bert'
 gem 'bencode'
-gem 'bson'
 gem 'multi_json'
+alternatives :mri => 'bson_ext', :jruby => 'bson'
+alternatives :mri => 'ox'
+alternatives :mri => 'msgpack', :jruby => 'msgpack-jruby'
+alternatives :mri => 'bert'
+
+# Compressors used by Transformer
+alternatives :mri => 'ruby-lzma'
+alternatives :mri => 'qlzruby'
+alternatives :mri => 'lzoruby'
+alternatives :mri => 'snappy'
 
 # Backends
 gem 'dm-core'
@@ -26,23 +42,13 @@ gem 'sequel'
 gem 'dalli'
 gem 'riak-client'
 gem 'hashery'
-
-if defined?(JRUBY_VERSION)
-  gem 'msgpack-jruby'
-  gem 'jdbc-sqlite3'
-  gem 'activerecord-jdbc-adapter'
-  gem 'activerecord-jdbcsqlite3-adapter'
-  gem 'jruby-memcached'
-  gem 'ffi' # gdbm for jruby needs ffi
-  gem 'gdbm'
-else
-  gem 'msgpack'
-  gem 'tokyocabinet'
-  gem 'memcached'
-  gem 'sqlite3'
-  gem 'ox'
-  gem 'bson_ext'
-end
-
 #gem 'cassandra'
 #gem 'localmemcache'
+alternatives :mri => 'tokyocabinet'
+alternatives :mri => 'memcached', :jruby => 'jruby-memcached'
+alternatives :mri => 'sqlite3', :jruby => %w(jdbc-sqlite3 activerecord-jdbc-adapter activerecord-jdbcsqlite3-adapter)
+alternatives :jruby => %w(ffi gdbm) # gdbm for jruby needs ffi
+
+# Integration
+gem 'rack'
+gem 'rack-cache'

data/README.md

@@ -13,6 +13,7 @@ Juno is very feature rich:
 * Supports proxies (Similar to [Rack middlewares](http://rack.github.com/))
 * Custom serialization via `Juno::Transformer` proxy (Marshal/JSON/YAML and many more)
 * Custom key transformation via `Juno::Transformer` proxy
+* Value compression via `Juno::Transformer` proxy (Zlib, Snappy, QuickLZ, LZO)
 * Expiration for all stores (Added via proxy if not supported natively)
 
 Supported backends
@@ -130,8 +131,8 @@ If you want to have control over the proxies, you have to use `Juno.build`:
 store = Juno.build do
   # Adds expires proxy
   use :Expires
-  # Transform key and value using Marshal
-  use :Transformer, :key => :marshal, :value => :marshal
+  # Transform key using Marshal and Base64 and value using Marshal
+  use :Transformer, :key => [:marshal, :base64], :value => :marshal
   # Memory backend
   adapter :Memory
 end
@@ -170,6 +171,44 @@ cache = Juno.build do
 end
 ~~~
 
+Framework Integration
+---------------------
+
+Inspired by [redis-store](https://github.com/jodosha/redis-store) there exist integration classes for Rack and Rack-Cache.
+
+Use Juno as a Rack session store:
+
+~~~ ruby
+require 'rack/session/juno'
+
+use Rack::Session::Juno, :store => :Redis
+use Rack::Session::Juno, :store => Juno.new(:Memory, :expires => true)
+
+use Rack::Session::Juno do
+  use :Expires
+  adapter :Memory
+end
+~~~
+
+Use Juno as a Rack-Cache store:
+
+~~~ ruby
+require 'rack/cache/juno'
+
+use Rack::Cache,
+      :metastore   => 'juno://Memory?expires=true',
+      :entitystore => 'juno://Memory?expires=true'
+
+# Or used named Juno stores
+Rack::Cache::Juno['named_metastore'] = Juno.build do
+  use :Expires
+  adapter :Memory
+end
+use Rack::Cache,
+      :metastore => 'juno://named_metastore',
+      :entity_store => 'juno://named_entitystore'
+~~~
+
 Alternatives
 ------------
 

data/Rakefile

@@ -14,7 +14,7 @@ namespace :test do
     if defined?(JRUBY_VERSION)
       puts 'No tests executed in parallel in JRuby'
     else
-      specs = Dir['spec/*_spec.rb'].reject {|s| s =~ /memcached|redis/ }
+      specs = Dir['spec/*/*_spec.rb'].reject {|s| s =~ /memcached|redis/ }
       sh("parallel_rspec -m 15 #{specs.join(' ')}")
     end
   end
@@ -22,9 +22,9 @@ namespace :test do
   task :non_parallel do
     if defined?(JRUBY_VERSION)
       # Run all tests in jruby non-parallel
-      sh('rspec spec/*_spec.rb')
+      sh('rspec spec/*/*_spec.rb')
     else
-      specs = Dir['spec/*_spec.rb'].select {|s| s =~ /memcached|redis/ }
+      specs = Dir['spec/*/*_spec.rb'].select {|s| s =~ /memcached|redis/ }
       sh("rspec #{specs.join(' ')}")
     end
   end

data/juno.gemspec

@@ -3,17 +3,17 @@ require File.dirname(__FILE__) + '/lib/juno/version'
 require 'date'
 
 Gem::Specification.new do |s|
-  s.name = 'juno'
-  s.version = Juno::VERSION
-  s.date = Date.today.to_s
-  s.authors = ['Yehuda Katz', 'Derek Kastner', 'Daniel Mendler']
-  s.email = %w{wycats@gmail.com dkastner@gmail.com mail@daniel-mendler.de}
-  s.description = 'A unified interface to key/value stores (moneta replacement)'
+  s.name             = 'juno'
+  s.version          = Juno::VERSION
+  s.date             = Date.today.to_s
+  s.authors          = ['Daniel Mendler', 'Yehuda Katz', 'Derek Kastner']
+  s.email            = %w{mail@daniel-mendler.de wycats@gmail.com dkastner@gmail.com}
+  s.description      = 'A unified interface to key/value stores (moneta replacement)'
   s.extra_rdoc_files = %w{README.md SPEC.md LICENSE}
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.homepage = 'http://github.com/minad/juno'
-  s.require_paths = ['lib']
-  s.summary = %{A unified interface to key/value stores, including MongoDB, Redis, Tokyo, and ActiveRecord}
+  s.files            = `git ls-files`.split("\n")
+  s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables      = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.homepage         = 'http://github.com/minad/juno'
+  s.require_paths    = ['lib']
+  s.summary          = %{A unified interface to key/value stores, including MongoDB, Redis, Tokyo, and ActiveRecord}
 end

data/lib/juno.rb

@@ -70,17 +70,17 @@ module Juno
     when :Memcached, :MemcachedDalli, :MemcachedNative
       # Memcached accept only base64 keys, expires already supported
       expires = false
-      transformer = {:key => [:marshal, :base64], :value => :marshal}
+      transformer[:key] = [:marshal, :base64]
     when :PStore, :YAML, :DataMapper, :Null
       # For PStore, YAML and DataMapper only the key has to be a string
-      transformer = {:key => :marshal}
+      transformer.delete(:value)
     when :HashFile
       # Use spreading hashes
-      transformer = {:key => [:marshal, :md5, :spread], :value => :marshal}
+      transformer[:key] = [:marshal, :md5, :spread]
       name = :File
     when :File
       # Use escaping
-      transformer = {:key => [:marshal, :escape], :value => :marshal}
+      transformer[:key] = [:marshal, :escape]
     when :Cassandra, :Redis
       # Expires already supported
       expires = false

data/lib/juno/adapters/couch.rb

@@ -12,7 +12,7 @@ module Juno
       # Options:
       # * :db - Couch database
       def initialize(options = {})
-        raise 'No option :db specified' unless options[:db]
+        raise 'Option :db is required' unless options[:db]
         @db = ::CouchRest.database!(options[:db])
       end
 

data/lib/juno/adapters/datamapper.rb

@@ -21,7 +21,7 @@ module Juno
       # * :repository - Repository name (default :juno)
       # * :table - Table name (default :juno)
       def initialize(options = {})
-        raise 'No option :setup specified' unless options[:setup]
+        raise 'Option :setup is required' unless options[:setup]
         @repository = options.delete(:repository) || :juno
         Store.storage_names[@repository] = (options.delete(:table) || :juno).to_s
         ::DataMapper.setup(@repository, options[:setup])

data/lib/juno/adapters/dbm.rb

@@ -12,7 +12,7 @@ module Juno
       # Options:
       # * :file - Database file
       def initialize(options = {})
-        raise 'No option :file specified' unless options[:file]
+        raise 'Option :file is required' unless options[:file]
         @memory = ::DBM.new(options[:file])
       end
 

data/lib/juno/adapters/file.rb

@@ -6,7 +6,7 @@ module Juno
     # @api public
     class File < Base
       def initialize(options = {})
-        raise 'No option :dir specified' unless @dir = options[:dir]
+        raise 'Option :dir is required' unless @dir = options[:dir]
         FileUtils.mkpath(@dir)
         raise "#{@dir} is not a dir" unless ::File.directory?(@dir)
       end

data/lib/juno/adapters/fog.rb

@@ -13,7 +13,7 @@ module Juno
       # * :dir - Fog directory
       # * Other options passed to Fog::Storage#new
       def initialize(options = {})
-        raise 'No option :dir specified' unless dir = options.delete(:dir)
+        raise 'Option :dir is required' unless dir = options.delete(:dir)
         storage = ::Fog::Storage.new(options)
         @directory = storage.directories.create(:key => dir)
       end

data/lib/juno/adapters/gdbm.rb

@@ -12,7 +12,7 @@ module Juno
       # Options:
       # * :file - Database file
       def initialize(options = {})
-        raise 'No option :file specified' unless options[:file]
+        raise 'Option :file is required' unless options[:file]
         @memory = ::GDBM.new(options[:file])
       end
 

data/lib/juno/adapters/localmemcache.rb

@@ -12,7 +12,7 @@ module Juno
       # Options:
       # * :file - Database file
       def initialize(options = {})
-        raise 'No option :file specified' unless options[:file]
+        raise 'Option :file is required' unless options[:file]
         @memory = ::LocalMemCache.new(:filename => options[:file])
       end
 

data/lib/juno/adapters/pstore.rb

@@ -12,7 +12,7 @@ module Juno
       # Options:
       # * :file - PStore file
       def initialize(options = {})
-        raise 'No option :file specified' unless options[:file]
+        raise 'Option :file is required' unless options[:file]
         FileUtils.mkpath(::File.dirname(options[:file]))
         @pstore = new_store(options)
       end

data/lib/juno/adapters/redis.rb

@@ -32,9 +32,10 @@ module Juno
       end
 
       def store(key, value, options = {})
-        @redis.set(key, value)
         if expires = options[:expires]
-          @redis.expire(key, expires)
+          @redis.setex(key, expires, value)
+        else
+          @redis.set(key, value)
         end
         value
       end

data/lib/juno/adapters/sdbm.rb

@@ -12,7 +12,7 @@ module Juno
       # Options:
       # * :file - Database file
       def initialize(options = {})
-        raise 'No option :file specified' unless options[:file]
+        raise 'Option :file is required' unless options[:file]
         @memory = ::SDBM.new(options[:file])
       end
 

data/lib/juno/adapters/sequel.rb

@@ -14,7 +14,7 @@ module Juno
       # * :table - Table name (default :juno)
       # * All other options passed to Sequel#connect
       def initialize(options = {})
-        raise 'No option :db specified' unless db = options.delete(:db)
+        raise 'Option :db is required' unless db = options.delete(:db)
         @table = options.delete(:table) || :juno
         @db = ::Sequel.connect(db, options)
         @db.create_table?(@table) do

data/lib/juno/adapters/sqlite.rb

@@ -13,7 +13,7 @@ module Juno
       # * :file - Database file
       # * :table - Table name (default juno)
       def initialize(options = {})
-        raise 'No option :file specified' unless options[:file]
+        raise 'Option :file is required' unless options[:file]
         table = options[:table] || 'juno'
         @db = ::SQLite3::Database.new(options[:file])
         @db.execute("create table if not exists #{table} (k blob not null primary key, v blob)")

data/lib/juno/adapters/tokyocabinet.rb

@@ -14,7 +14,7 @@ module Juno
       # * :type - Database type (default :hdb, :bdb and :hdb possible)
       def initialize(options = {})
         file = options[:file]
-        raise 'No option :file specified' unless options[:file]
+        raise 'Option :file is required' unless options[:file]
         if options[:type] == :bdb
           @memory = ::TokyoCabinet::BDB.new
           @memory.open(file, ::TokyoCabinet::BDB::OWRITER | ::TokyoCabinet::BDB::OCREAT)

data/lib/juno/builder.rb

@@ -2,6 +2,7 @@ module Juno
   # Builder implements the DSL to build a chain of store proxies
   # @api private
   class Builder
+    # @api private
     def build
       klass, options, block = @proxies.first
       store = klass.new(options, &block)
@@ -18,12 +19,21 @@ module Juno
       instance_eval(&block)
     end
 
+    # Add proxy to chain
+    #
+    # @param [Symbol or Class] proxy Name of proxy class or proxy class
+    # @param [Hash] options Options hash
     def use(proxy, options = {}, &block)
       proxy = Juno.const_get(proxy) if Symbol === proxy
       raise 'You must give a Class or a Symbol' unless Class === proxy
       @proxies.unshift [proxy, options, block]
+      nil
     end
 
+    # Add adapter to chain
+    #
+    # @param [Symbol] name Name of adapter class
+    # @param [Hash] options Options hash
     def adapter(name, options = {}, &block)
       use(Adapters.const_get(name), options, &block)
     end

data/lib/juno/cache.rb

@@ -12,6 +12,7 @@ module Juno
   #
   # @api public
   class Cache < Base
+    # @api private
     class DSL
       def initialize(options, &block)
         @cache, @backend = options[:cache], options[:backend]

data/lib/juno/expires.rb

@@ -1,7 +1,7 @@
 module Juno
   # Adds expiration support to the underlying store
   #
-  # #store and #load support the :expires options to set/update
+  # #store and #load support the :expires option to set/update
   # the expiration time.
   #
   # @api public

data/lib/juno/proxy.rb

@@ -63,6 +63,8 @@ module Juno
       self
     end
 
+    # Close this store
+    # @api public
     def close
       @adapter.close
     end

data/lib/juno/stack.rb

@@ -14,6 +14,7 @@ module Juno
   #
   # @api public
   class Stack < Base
+    # @api private
     class DSL
       attr_reader :stack
 

data/lib/juno/transformer.rb

@@ -10,6 +10,7 @@ module Juno
   #
   # @api public
   class Transformer < Proxy
+    # Available value transformers (Encoding and decoding)
     VALUE_TRANSFORMER = {
       :base64   => { :load => "value.unpack('m').first",         :dump => "[value].pack('m').strip" },
       :bencode  => { :load => '::BEncode.load(value)',           :dump => '::BEncode.dump(value)', :require => 'bencode' },
@@ -17,14 +18,19 @@ module Juno
       :bson     => { :load => "::BSON.deserialize(value)['v']",  :dump => "::BSON.serialize('v'=>value)", :require => 'bson' },
       :compress => { :load => '::Zlib::Inflate.inflate(value)',  :dump => '::Zlib::Deflate.deflate(value)', :require => 'zlib' },
       :json     => { :load => '::MultiJson.load(value).first',   :dump => '::MultiJson.dump([value])', :require => 'multi_json' },
+      :lzma     => { :load => '::LZMA.decompress(value)',        :dump => '::LZMA.compress(value)', :require => 'lzma' },
+      :lzo      => { :load => '::LZO.decompress(value)',         :dump => '::LZO.compress(value)', :require => 'lzoruby' },
       :marshal  => { :load => '::Marshal.load(value)',           :dump => '::Marshal.dump(value)' },
       :msgpack  => { :load => '::MessagePack.unpack(value)',     :dump => '::MessagePack.pack(value)', :require => 'msgpack' },
       :ox       => { :load => '::Ox.parse_obj(value)',           :dump => '::Ox.dump(value)', :require => 'ox' },
+      :snappy   => { :load => '::Snappy.inflate(value)',         :dump => '::Snappy.deflate(value)', :require => 'snappy' },
+      :quicklz  => { :load => '::QuickLZ.decompress(value)',     :dump => '::QuickLZ.compress(value)', :require => 'qlzruby' },
       :tnet     => { :load => '::TNetstring.parse(value).first', :dump => '::TNetstring.dump(value)', :require => 'tnetstring' },
       :uuencode => { :load => "value.unpack('u').first",         :dump => "[value].pack('u').strip" },
-      :yaml     => { :load => '::YAML.load(value)',              :dump => '::YAML.dump(value)', :require => 'yaml' }
+      :yaml     => { :load => '::YAML.load(value)',              :dump => '::YAML.dump(value)', :require => 'yaml' },
     }
 
+    # Available key transformers (Only encoding, one direction)
     KEY_TRANSFORMER = {
       :base64   => { :transform => "[key].pack('m').strip" },
       :bencode  => { :transform => '::BEncode.dump(key)', :require => 'bencode' },
@@ -35,7 +41,8 @@ module Juno
       :marshal  => { :transform => '(tmp = key; String === tmp ? tmp : ::Marshal.dump(tmp))' },
       :md5      => { :transform => '::Digest::MD5.hexdigest(key)', :require => 'digest/md5' },
       :msgpack  => { :transform => '(tmp = key; String === tmp ? tmp : ::MessagePack.pack(tmp))', :require => 'msgpack' },
-      :ox       => { :transform => '(tmp = key; String === tmp ? tmp : ::Ox.dump(tmp))' },
+      :prefix   => { :transform => '@prefix+key' },
+      :ox       => { :transform => '(tmp = key; String === tmp ? tmp : ::Ox.dump(tmp))', :require => 'ox' },
       :spread   => { :transform => '(tmp = key; ::File.join(tmp[0..1], tmp[2..-1]))' },
       :tnet     => { :transform => '(tmp = key; String === tmp ? tmp : ::TNetstring.dump(tmp))', :require => 'tnetstring' },
       :uuencode => { :transform => "[key].pack('u').strip" },
@@ -44,9 +51,34 @@ module Juno
 
     @classes = {}
 
+    def initialize(adapter, options = {})
+      super
+      @prefix = options[:prefix]
+    end
+
     class << self
       alias_method :original_new, :new
 
+      # Constructor
+      #
+      # @param [Juno store] adapter The underlying store
+      # @param [Hash] options
+      #
+      # Options:
+      # * :key - List of key transformers in the order in which they should be applied
+      # * :value - List of value transformers in the order in which they should be applied
+      # * :prefix - Prefix string for key namespacing (Used by the :prefix key transformer)
+      def new(adapter, options = {})
+        keys = [options[:key]].flatten.compact
+        values = [options[:value]].flatten.compact
+        raise 'Option :key or :value is required' if keys.empty? && values.empty?
+        klass = @classes["#{keys.join('-')}+#{values.join('-')}"] ||= compile(keys, values)
+        raise 'Option :prefix is required' if keys.include?(:prefix) && !options[:prefix]
+        klass.original_new(adapter, options)
+      end
+
+      private
+
       def compile(keys, values)
         tmp, key = 0, 'key'
         keys.each do |tn|
@@ -101,22 +133,6 @@ module Juno
         end
         klass
       end
-
-      # Constructor
-      #
-      # @param [Juno store] adapter The underlying store
-      # @param [Hash] options
-      #
-      # Options:
-      # * :key - List of key transformers in the order in which they should be applied
-      # * :value - List of value transformers in the order in which they should be applied
-      def new(adapter, 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(adapter, options)
-      end
     end
   end
 end