juno 0.2.8 → 0.3.0

data/lib/juno/adapters/localmemcache.rb

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

data/lib/juno/adapters/mongo.rb

@@ -29,7 +29,7 @@ module Juno
 
       def load(key, options = {})
         value = @collection.find_one('_id' => key)
-        value ? value['data'].to_s : nil
+        value ? value['value'].to_s : nil
       end
 
       def delete(key, options = {})
@@ -40,7 +40,7 @@ module Juno
 
       def store(key, value, options = {})
         @collection.update({ '_id' => key },
-                           { '_id' => key, 'data' => ::BSON::Binary.new(value) },
+                           { '_id' => key, 'value' => ::BSON::Binary.new(value) },
                            { :upsert => true })
         value
       end

data/lib/juno/adapters/pstore.rb

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

data/lib/juno/adapters/riak.rb

@@ -14,9 +14,11 @@ module Juno
       #
       # Options:
       # * :bucket - Bucket name (default juno)
+      # * :content_type - Default content type (default application/octet-stream)
       # * All other options passed to Riak::Client#new
       def initialize(options = {})
         bucket = options.delete(:bucket) || 'juno'
+        @content_type = options.delete(:content_type) || 'application/octet-stream'
         @bucket = ::Riak::Client.new(options).bucket(bucket)
       end
 
@@ -38,7 +40,7 @@ module Juno
 
       def store(key, value, options = {})
         obj = ::Riak::RObject.new(@bucket, key)
-        obj.content_type = 'application/octet-stream'
+        obj.content_type = options[:content_type] || @content_type
         obj.raw_data = value
         obj.store(options)
         value

data/lib/juno/adapters/sdbm.rb

@@ -12,7 +12,7 @@ module Juno
       # Options:
       # * :file - Database file
       def initialize(options = {})
-        raise 'Option :file is required' unless options[:file]
+        raise ArgumentError, '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 'Option :db is required' unless db = options.delete(:db)
+        raise ArgumentError, '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 'Option :file is required' unless options[:file]
+        raise ArgumentError, '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 'Option :file is required' unless options[:file]
+        raise ArgumentError, '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/base.rb

@@ -7,15 +7,27 @@ module Juno
     def close
     end
 
-    # Fetch value with key. Return default if value is nil.
+    # Fetch value with key
+    #
+    # This is a overloaded method:
+    #
+    # * fetch(key, options = {}, &block) retrieve a key. if the key is not available, execute the
+    #   block and return its return value.
+    #
+    # * fetch(key, value, options = {}) retrieve a key. if the key is not available, return the value.
     #
     # @param [Object] key
-    # @param [Object] value Default value
+    # @param [Object] default Default value
     # @param [Hash] options
     # @return [Object] value from store
     # @api public
-    def fetch(key, value = nil, options = {})
-      load(key, options) || (block_given? && yield(key)) || value
+    def fetch(key, default = nil, options = nil)
+      if block_given?
+        raise ArgumentError, 'Only one argument accepted if block is given' if options
+        load(key, default || {}) || yield(key)
+      else
+        load(key, options || {}) || default
+      end
     end
 
     # Fetch value with key. Return nil if the key doesn't exist

data/lib/juno/builder.rb

@@ -12,7 +12,7 @@ module Juno
     end
 
     def initialize(&block)
-      raise 'No block given' unless block_given?
+      raise ArgumentError, 'No block given' unless block_given?
       @proxies = []
       instance_eval(&block)
     end
@@ -23,7 +23,7 @@ module Juno
     # @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
+      raise ArgumentError, 'You must give a Class or a Symbol' unless Class === proxy
       @proxies.unshift [proxy, options, block]
       nil
     end

data/lib/juno/cache.rb

@@ -20,13 +20,13 @@ module Juno
 
       def backend(store = nil, &block)
         raise 'Backend already set' if @backend
-        raise 'Only argument or block allowed' if store && block
+        raise ArgumentError, 'Only argument or block allowed' if store && block
         @backend = store || Juno.build(&block)
       end
 
       def cache(store = nil, &block)
         raise 'Cache already set' if @cache
-        raise 'Only argument or block allowed' if store && block
+        raise ArgumentError, 'Only argument or block allowed' if store && block
         @cache = store || Juno.build(&block)
       end
 

data/lib/juno/stack.rb

@@ -23,7 +23,7 @@ module Juno
       end
 
       def add(store = nil, &block)
-        raise 'Only argument or block allowed' if store && block
+        raise ArgumentError, 'Only argument or block allowed' if store && block
         @stack << (store || Juno.build(&block))
         nil
       end

data/lib/juno/transformer.rb

@@ -11,7 +11,7 @@ module Juno
   class Transformer < Proxy
     def initialize(adapter, options = {})
       super
-      @prefix = options[:prefix]
+      @prefix, @secret = options[:prefix], options[:secret]
     end
 
     class << self
@@ -26,14 +26,14 @@ module Juno
       # * :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)
+      # * :secret - HMAC secret to verify values (Used by the :hmac value 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?
-        raise 'Option :prefix is required' if keys.include?(:prefix) && !options[:prefix]
-        name = ''
-        name << keys.map(&:to_s).map(&:capitalize).join << 'Key' unless keys.empty?
-        name << values.map(&:to_s).map(&:capitalize).join << 'Value' unless values.empty?
+        raise ArgumentError, 'Option :key or :value is required' if keys.empty? && values.empty?
+        raise ArgumentError, 'Option :prefix is required for :prefix key transformer' if keys.include?(:prefix) && !options[:prefix]
+        raise ArgumentError, 'Option :secret is required for :hmac value transformer' if values.include?(:hmac) && !options[:secret]
+        name = class_name(keys, values)
         const_set(name, compile(keys, values)) unless const_defined?(name)
         const_get(name).original_new(adapter, options)
       end
@@ -41,12 +41,12 @@ module Juno
       private
 
       def compile(keys, values)
-        raise 'Invalid key transformer chain' if KEY_TRANSFORMER !~ keys.map(&:inspect).join
-        raise 'Invalid value transformer chain' if VALUE_TRANSFORMER !~ values.map(&:inspect).join
+        raise ArgumentError, 'Invalid key transformer chain' if KEY_TRANSFORMER !~ keys.map(&:inspect).join
+        raise ArgumentError, 'Invalid value transformer chain' if VALUE_TRANSFORMER !~ values.map(&:inspect).join
 
         key = compile_transformer(keys, 'key')
 
-        klass = Class.new(Transformer)
+        klass = Class.new(self)
         if values.empty?
           klass.class_eval <<-end_eval, __FILE__, __LINE__
             def key?(key, options = {})
@@ -97,7 +97,7 @@ module Juno
       # Returned compiled transformer code string
       def compile_transformer(transformer, var, i = 2)
         transformer.inject(var) do |value, name|
-          raise "Unknown transformer #{name}" unless t = TRANSFORMER[name]
+          raise ArgumentError, "Unknown transformer #{name}" unless t = TRANSFORMER[name]
           require t[3] if t[3]
           code = t[i]
           if t[0] == :serialize && var == 'key'
@@ -107,6 +107,11 @@ module Juno
           end
         end
       end
+
+      def class_name(keys, values)
+        (keys.empty? ? '' : keys.map(&:to_s).map(&:capitalize).join << 'Key') <<
+          (values.empty? ? '' : values.map(&:to_s).map(&:capitalize).join << 'Value')
+      end
     end
 
     # Available key/value transformers
@@ -128,8 +133,8 @@ module Juno
       :zlib     => [ :compress,  '::Zlib::Inflate.inflate(value)',  '::Zlib::Deflate.deflate(value)',    'zlib'          ],
       :base64   => [ :encode,    "value.unpack('m').first",         "[value].pack('m').strip"                            ],
       :uuencode => [ :encode,    "value.unpack('u').first",         "[value].pack('u').strip"                            ],
-      :escape   => [ :encode,    "value.gsub(/((?:%[0-9a-fA-F]{2})+)/){ [$1.delete('%')].pack('H*') }",
-                                 "value.gsub(/[^a-zA-Z0-9_-]+/){ '%' + $&.unpack('H2' * $&.bytesize).join('%').upcase }" ],
+      :escape   => [ :encode,    'Escape.unescape(value)',          'Escape.escape(value)'                               ],
+      :hmac     => [ :hmac,      'HMAC.verify(value, @secret)',     'HMAC.sign(value, @secret)' ,        'openssl'       ],
       :md5      => [ :digest,    nil,                               '::Digest::MD5.hexdigest(value)',    'digest/md5'    ],
       :rmd160   => [ :digest,    nil,                               '::Digest::RMD160.hexdigest(value)', 'digest/rmd160' ],
       :sha1     => [ :digest,    nil,                               '::Digest::SHA1.hexdigest(value)',   'digest/sha1'   ],
@@ -141,9 +146,30 @@ module Juno
     }
 
     # Allowed value transformers (Read it like a regular expression!)
-    VALUE_TRANSFORMER = compile_validator('serialize? compress? encode?')
+    VALUE_TRANSFORMER = compile_validator('serialize? compress? hmac? encode?')
 
     # Allowed key transformers (Read it like a regular expression!)
     KEY_TRANSFORMER = compile_validator('serialize? prefix? (encode | (digest spread?))?')
+
+    module Escape
+      def self.escape(value)
+        value.gsub(/[^a-zA-Z0-9_-]+/){ '%' + $&.unpack('H2' * $&.bytesize).join('%').upcase }
+      end
+
+      def self.unescape(value)
+        value.gsub(/((?:%[0-9a-fA-F]{2})+)/){ [$1.delete('%')].pack('H*') }
+      end
+    end
+
+    module HMAC
+      def self.verify(value, secret)
+        hash, value = value[0..31], value[32..-1]
+        value if hash == OpenSSL::HMAC.digest(OpenSSL::Digest::Digest.new('sha256'), secret, value)
+      end
+
+      def self.sign(value, secret)
+        OpenSSL::HMAC.digest(OpenSSL::Digest::Digest.new('sha256'), secret, value) << value
+      end
+    end
   end
 end

data/lib/juno/version.rb

@@ -1,5 +1,5 @@
 module Juno
   # Juno version number
   # @api public
-  VERSION = '0.2.8'
+  VERSION = '0.3.0'
 end

data/lib/rack/juno_cookies.rb

@@ -9,7 +9,7 @@ module Rack
   #   # Add Rack::JunoCookies somewhere in your rack stack
   #   use Rack::JunoCookies
   #
-  #   run lambda{|env| [200,{},[]] }
+  #   run lambda { |env| [200, {}, []] }
   #   # But this doesn't do much
   #
   # @example config.ru
@@ -23,20 +23,21 @@ module Rack
   #     adapter :Cookie
   #   end
   #
-  #   run lambda { |env|
+  #   run lambda do |env|
   #     req = Rack::Request.new(env)
-  #     req.cookies #=> is now a Juno store!!
+  #     req.cookies #=> is now a Juno store!
+  #     env['rack.request.cookie_hash'] #=> is now a Juno store!
   #     req.cookies['key'] #=> retrieves 'juno.key'
   #     req.cookies['key'] = 'value' #=> sets 'juno.key'
   #     req.cookies.delete('key') #=> removes 'juno.key'
-  #     [200,{},[]]
-  #   }
+  #     [200, {}, []]
+  #   end
   #
   class JunoCookies
     def initialize(app, options = {}, &block)
-      @app = app
+      @app, @pool = app, []
       if block
-        raise 'Use either block or options' unless options.empty?
+        raise ArgumentError, 'Use either block or options' unless options.empty?
         @builder = Juno::Builder.new(&block)
       else
         @builder = Juno::Builder.new { adapter :Cookie, options }
@@ -44,7 +45,7 @@ module Rack
     end
 
     def call(env)
-      stores = @builder.build
+      stores = @pool.pop || @builder.build
       env['rack.request.cookie_hash'] = stores.last
       env['rack.request.cookie_string'] = env['HTTP_COOKIE']
       stores.first.reset(Rack::Utils.parse_query(env['HTTP_COOKIE']))
@@ -56,6 +57,7 @@ module Rack
           Rack::Utils.set_cookie_header!(headers, key, cookie)
         end
       end
+      @pool << stores
       [status, headers, body]
     end
   end

data/lib/rack/session/juno.rb

@@ -10,10 +10,10 @@ module Rack
       def initialize(app, options = {}, &block)
         super
         if block
-          raise 'Use either block or option :store' if options[:store]
+          raise ArgumentError, 'Use either block or option :store' if options[:store]
           @pool = ::Juno.build(&block)
         else
-          raise 'Option :store is required' unless @pool = options[:store]
+          raise ArgumentError, 'Option :store is required' unless @pool = options[:store]
           @pool = ::Juno.new(@pool, :expires => true) if Symbol === @pool
         end
         @mutex = Mutex.new

data/spec/generate.rb

@@ -76,7 +76,8 @@ TESTS = {
   },
   'simple_cassandra' => {
     :store => :Cassandra,
-    :specs => EXPIRES_SPECS
+    :options => ':keyspace => "simple_cassandra"',
+    :specs => EXPIRES_SPECS,
   },
   'simple_dbm' => {
     :store => :DBM,
@@ -105,6 +106,15 @@ TESTS = {
     :options => ':file => File.join(make_tempdir, "simple_sdbm_with_expires"), :expires => true',
     :specs => EXPIRES_SPECS
   },
+  'simple_leveldb' => {
+    :store => :LevelDB,
+    :options => ':dir => File.join(make_tempdir, "simple_leveldb")'
+  },
+  'simple_leveldb_with_expires' => {
+    :store => :LevelDB,
+    :options => ':dir => File.join(make_tempdir, "simple_leveldb_with_expires"), :expires => true',
+    :specs => EXPIRES_SPECS
+  },
   'simple_pstore' => {
     :store => :PStore,
     :options => ':file => File.join(make_tempdir, "simple_pstore")'
@@ -476,82 +486,89 @@ end},
 end},
     :specs => [:null, :store, :returndifferent]
   },
+  'transformer_marshal_hmac' => {
+    :build => %{Juno.build do
+  use :Transformer, :key => :marshal, :value => [:marshal, :hmac], :secret => 'secret'
+  adapter :Memory
+end},
+    :specs => SIMPLE_SPECS
+  },
   'transformer_marshal_base64' => {
     :build => %{Juno.build do
   use :Transformer, :key => [:marshal, :base64], :value => [:marshal, :base64]
   adapter :Memory
 end},
-    :specs => [:null, :store, :returndifferent, :marshallable_key]
+    :specs => SIMPLE_SPECS
   },
   'transformer_marshal_prefix' => {
     :build => %{Juno.build do
   use :Transformer, :key => [:marshal, :prefix], :value => :marshal, :prefix => 'juno'
   adapter :Memory
 end},
-    :specs => [:null, :store, :returndifferent, :marshallable_key]
+    :specs => SIMPLE_SPECS
   },
   'transformer_marshal_uuencode' => {
     :build => %{Juno.build do
   use :Transformer, :key => [:marshal, :uuencode], :value => [:marshal, :uuencode]
   adapter :Memory
 end},
-    :specs => [:null, :store, :returndifferent, :marshallable_key]
+    :specs => SIMPLE_SPECS
   },
   'transformer_marshal_escape' => {
     :build => %{Juno.build do
   use :Transformer, :key => [:marshal, :escape], :value => :marshal
   adapter :Memory
 end},
-    :specs => [:null, :store, :returndifferent, :marshallable_key]
+    :specs => SIMPLE_SPECS
   },
   'transformer_marshal_md5' => {
     :build => %{Juno.build do
   use :Transformer, :key => [:marshal, :md5], :value => :marshal
   adapter :Memory
 end},
-    :specs => [:null, :store, :returndifferent, :marshallable_key]
+    :specs => SIMPLE_SPECS
   },
   'transformer_marshal_sha1' => {
     :build => %{Juno.build do
   use :Transformer, :key => [:marshal, :sha1], :value => :marshal
   adapter :Memory
 end},
-    :specs => [:null, :store, :returndifferent, :marshallable_key]
+    :specs => SIMPLE_SPECS
   },
   'transformer_marshal_sha256' => {
     :build => %{Juno.build do
   use :Transformer, :key => [:marshal, :sha256], :value => :marshal
   adapter :Memory
 end},
-    :specs => [:null, :store, :returndifferent, :marshallable_key]
+    :specs => SIMPLE_SPECS
   },
   'transformer_marshal_sha384' => {
     :build => %{Juno.build do
   use :Transformer, :key => [:marshal, :sha384], :value => :marshal
   adapter :Memory
 end},
-    :specs => [:null, :store, :returndifferent, :marshallable_key]
+    :specs => SIMPLE_SPECS
   },
   'transformer_marshal_sha512' => {
     :build => %{Juno.build do
   use :Transformer, :key => [:marshal, :sha512], :value => :marshal
   adapter :Memory
 end},
-    :specs => [:null, :store, :returndifferent, :marshallable_key]
+    :specs => SIMPLE_SPECS
   },
   'transformer_marshal_rmd160' => {
     :build => %{Juno.build do
   use :Transformer, :key => [:marshal, :rmd160], :value => :marshal
   adapter :Memory
 end},
-    :specs => [:null, :store, :returndifferent, :marshallable_key]
+    :specs => SIMPLE_SPECS
   },
   'transformer_marshal_md5_spread' => {
     :build => %{Juno.build do
   use :Transformer, :key => [:marshal, :md5, :spread], :value => :marshal
   adapter :Memory
 end},
-    :specs => [:null, :store, :returndifferent, :marshallable_key]
+    :specs => SIMPLE_SPECS
   },
   'adapter_activerecord' => {
     :build => "Juno::Adapters::ActiveRecord.new(:connection => { :adapter => (defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3'), :database => File.join(make_tempdir, 'adapter_activerecord') })",
@@ -573,7 +590,7 @@ end
 }
   },
   'adapter_cassandra' => {
-    :build => "Juno::Adapters::Cassandra.new",
+    :build => "Juno::Adapters::Cassandra.new(:keyspace => 'adapter_cassandra')",
     :specs => ADAPTER_SPECS
   },
   'adapter_cookie' => {
@@ -692,6 +709,10 @@ end
     :build => 'Juno::Adapters::SDBM.new(:file => File.join(make_tempdir, "adapter_sdbm"))',
     :specs => ADAPTER_SPECS
   },
+  'adapter_leveldb' => {
+    :build => 'Juno::Adapters::LevelDB.new(:dir => File.join(make_tempdir, "adapter_leveldb"))',
+    :specs => ADAPTER_SPECS
+  },
   'adapter_sequel' => {
     :build => 'Juno::Adapters::Sequel.new(:db => (defined?(JRUBY_VERSION) ? "jdbc:sqlite:" : "sqlite:") + File.join(make_tempdir, "adapter_sequel"))',
     :specs => ADAPTER_SPECS
@@ -775,7 +796,8 @@ end
 it 'should accept options' do
   store.key?(#{key1}, :option1 => 1).should == false
   store.load(#{key1}, :option2 => 2).should == nil
-  store.fetch(#{key1}, nil, :option3 => 3).should == nil
+  store.fetch(#{key1}, 42, :option3 => 3).should == 42
+  store.fetch(#{key1}, :option3 => 3) { 42 }.should == 42
   store.delete(#{key1}, :option4 => 4).should == nil
   store.clear(:option5 => 5).should equal(store)
   store.store(#{key1}, #{val1}, :option6 => 6).should == #{val1}