moneta 0.7.1 → 0.7.2

data/lib/moneta/transformer.rb

@@ -10,19 +10,17 @@ module Moneta
   #
   # @example Bypass serialization
   #   store.store('key', 'value', :raw => true)
-  #   store['key'] => Error
-  #   store.load('key', :raw => true) => 'value'
+  #   store['key'] # raises an Exception
+  #   store.load('key', :raw => true) # returns 'value'
   #
   #   store['key'] = 'value'
-  #   store.load('key', :raw => true) => "\x04\bI\"\nvalue\x06:\x06ET"
+  #   store.load('key', :raw => true) # returns "\x04\bI\"\nvalue\x06:\x06ET"
   #
   # @api public
   class Transformer < Proxy
     class << self
       alias_method :original_new, :new
 
-      # Constructor
-      #
       # @param [Moneta store] adapter The underlying store
       # @param [Hash] options
       # @return [Transformer] new Moneta transformer
@@ -31,28 +29,25 @@ module Moneta
       # @option options [String] :prefix Prefix string for key namespacing (Used by the :prefix key transformer)
       # @option options [String] :secret HMAC secret to verify values (Used by the :hmac value transformer)
       # @option options [Integer] :maxlen Maximum key length (Used by the :truncate key transformer)
-      # @option options [Boolean] :quiet Disable error message
       def new(adapter, options = {})
         keys = [options[:key]].flatten.compact
         values = [options[:value]].flatten.compact
         raise ArgumentError, 'Option :key or :value is required' if keys.empty? && values.empty?
         options[:prefix] ||= '' if keys.include?(:prefix)
-        name = class_name(options[:quiet] ? 'Quiet' : '', keys, values)
-        const_set(name, compile(options, keys, values)) unless const_defined?(name)
+        name = class_name(keys, values)
+        const_set(name, compile(keys, values)) unless const_defined?(name)
         const_get(name).original_new(adapter, options)
       end
 
       private
 
-      def compile(options, keys, values)
+      def compile(keys, values)
         @key_validator ||= compile_validator(KEY_TRANSFORMER)
         @value_validator ||= compile_validator(VALUE_TRANSFORMER)
 
         raise ArgumentError, 'Invalid key transformer chain' if @key_validator !~ keys.map(&:inspect).join
         raise ArgumentError, 'Invalid value transformer chain' if @value_validator !~ values.map(&:inspect).join
 
-        key = compile_transformer(keys, 'key')
-
         klass = Class.new(self)
         klass.class_eval <<-end_eval, __FILE__, __LINE__
           def initialize(adapter, options = {})
@@ -60,62 +55,90 @@ module Moneta
             #{compile_initializer('key', keys)}
             #{compile_initializer('value', values)}
           end
+        end_eval
+
+        key = compile_transformer(keys, 'key')
+        dump = compile_transformer(values, 'value')
+        load = compile_transformer(values.reverse, 'value', 1)
+
+        if values.empty?
+          compile_key_transformer(klass, key)
+        elsif keys.empty?
+          compile_value_transformer(klass, load, dump)
+        else
+          compile_key_value_transformer(klass, key, load, dump)
+        end
+
+        klass
+      end
+
+      def compile_key_transformer(klass, key)
+        klass.class_eval <<-end_eval, __FILE__, __LINE__
           def key?(key, options = {})
             @adapter.key?(#{key}, options)
           end
           def increment(key, amount = 1, options = {})
             @adapter.increment(#{key}, amount, options)
           end
+          def load(key, options = {})
+            options.include?(:raw) && (options = options.dup; options.delete(:raw))
+            @adapter.load(#{key}, options)
+          end
+          def store(key, value, options = {})
+            options.include?(:raw) && (options = options.dup; options.delete(:raw))
+            @adapter.store(#{key}, value, options)
+          end
+          def delete(key, options = {})
+            options.include?(:raw) && (options = options.dup; options.delete(:raw))
+            @adapter.delete(#{key}, options)
+          end
         end_eval
+      end
 
-        if values.empty?
-          klass.class_eval <<-end_eval, __FILE__, __LINE__
-            def load(key, options = {})
-              options.delete(:raw)
-              @adapter.load(#{key}, options)
-            end
-            def store(key, value, options = {})
-              options.delete(:raw)
-              @adapter.store(#{key}, value, options)
-            end
-            def delete(key, options = {})
-              options.delete(:raw)
-              @adapter.delete(#{key}, options)
-            end
-          end_eval
-        else
-          dump = compile_transformer(values, 'value')
-          load = compile_transformer(values.reverse, 'value', 1)
-
-          klass.class_eval <<-end_eval, __FILE__, __LINE__
-            def load(key, options = {})
-              raw = options.delete(:raw)
-              value = @adapter.load(#{key}, options)
-              begin
-                return #{load} if value && !raw
-              rescue Exception => ex
-                #{options[:quiet] ? '' : 'puts "Tried to load invalid value: #{ex.message}"'}
-              end
-              value
-            end
-            def store(key, value, options = {})
-              raw = options.delete(:raw)
-              @adapter.store(#{key}, raw ? value : #{dump}, options)
-              value
-            end
-            def delete(key, options = {})
-              raw = options.delete(:raw)
-              value = @adapter.delete(#{key}, options)
-              begin
-                return #{load} if value && !raw
-              rescue Exception => ex
-                #{options[:quiet] ? '' : 'puts "Tried to delete invalid value: #{ex.message}"'}
-              end
-              value
-            end
-          end_eval
-        end
-        klass
+      def compile_value_transformer(klass, load, dump)
+        klass.class_eval <<-end_eval, __FILE__, __LINE__
+          def load(key, options = {})
+            raw = options.include?(:raw) && (options = options.dup; options.delete(:raw))
+            value = @adapter.load(key, options)
+            value && !raw ? #{load} : value
+          end
+          def store(key, value, options = {})
+            raw = options.include?(:raw) && (options = options.dup; options.delete(:raw))
+            @adapter.store(key, raw ? value : #{dump}, options)
+            value
+          end
+          def delete(key, options = {})
+            raw = options.include?(:raw) && (options = options.dup; options.delete(:raw))
+            value = @adapter.delete(key, options)
+            value && !raw ? #{load} : value
+          end
+        end_eval
+      end
+
+      def compile_key_value_transformer(klass, key, load, dump)
+        klass.class_eval <<-end_eval, __FILE__, __LINE__
+          def key?(key, options = {})
+            @adapter.key?(#{key}, options)
+          end
+          def increment(key, amount = 1, options = {})
+            @adapter.increment(#{key}, amount, options)
+          end
+          def load(key, options = {})
+            raw = options.include?(:raw) && (options = options.dup; options.delete(:raw))
+            value = @adapter.load(#{key}, options)
+            value && !raw ? #{load} : value
+          end
+          def store(key, value, options = {})
+            raw = options.include?(:raw) && (options = options.dup; options.delete(:raw))
+            @adapter.store(#{key}, raw ? value : #{dump}, options)
+            value
+          end
+          def delete(key, options = {})
+            raw = options.include?(:raw) && (options = options.dup; options.delete(:raw))
+            value = @adapter.delete(#{key}, options)
+            value && !raw ? #{load} : value
+          end
+        end_eval
       end
 
       # Compile option initializer
@@ -149,8 +172,8 @@ module Moneta
         end
       end
 
-      def class_name(prefix, keys, values)
-        prefix << (keys.empty? ? '' : keys.map(&:to_s).map(&:capitalize).join << 'Key') <<
+      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

data/lib/moneta/version.rb

@@ -1,5 +1,5 @@
 module Moneta
   # Moneta version number
   # @api public
-  VERSION = '0.7.1'
+  VERSION = '0.7.2'
 end

data/lib/rack/moneta_rest.rb

@@ -0,0 +1,56 @@
+require 'moneta'
+
+module Rack
+  class MonetaRest
+    def initialize(store = nil, options = {}, &block)
+      if block
+        raise ArgumentError, 'Use either block or options' unless options.emtpy?
+        @store = ::Moneta.build(&block)
+      else
+        raise ArgumentError, 'Option :store is required' unless @store = store
+        @store = ::Moneta.new(@store, options) if Symbol === @store
+      end
+    end
+
+    def call(env)
+      key = env['PATH_INFO'][1..-1]
+      case env['REQUEST_METHOD']
+      when 'HEAD'
+        if @store.key?(key)
+          respond(200)
+        else
+          empty(404)
+        end
+      when 'GET'
+        if value = @store[key]
+          respond(200, value)
+        else
+          empty(404)
+        end
+      when 'POST', 'PUT'
+        respond(200, @store[key] = env['rack.input'].read)
+      when 'DELETE'
+        if key.empty?
+          @store.clear
+          empty(200)
+        else
+          respond(200, @store.delete(key))
+        end
+      else
+        empty(400)
+      end
+    rescue => ex
+      respond(500, ex.message)
+    end
+
+    private
+
+    def empty(status)
+      [status, {'Content-Type'=>'application/octet-stream', 'Content-Length' => '0'}, []]
+    end
+
+    def respond(status, value)
+      [status, {'Content-Type'=>'application/octet-stream', 'Content-Length' => value.bytesize.to_s}, [value]]
+    end
+  end
+end

data/moneta.gemspec

@@ -15,5 +15,5 @@ Gem::Specification.new do |s|
   s.executables      = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.homepage         = 'http://github.com/minad/moneta'
   s.require_paths    = ['lib']
-  s.summary          = %{A unified interface to key/value stores, including MongoDB, Redis, Tokyo, and ActiveRecord}
+  s.summary          = %{A unified interface to key/value stores, including Redis, Memcached, TokyoCabinet, ActiveRecord and many more}
 end

data/spec/active_support/cache_moneta_store_spec.rb

@@ -76,24 +76,24 @@ describe ActiveSupport::Cache::MonetaStore do
 
   it 'increments a key' do
     3.times { @store.increment 'counter' }
-    @store.read('counter').should == '3'
+    @store.read('counter', :raw => true).should == '3'
   end
 
   it 'decrements a key' do
     3.times { @store.increment 'counter' }
     2.times { @store.decrement 'counter' }
-    @store.read('counter').should == '1'
+    @store.read('counter', :raw => true).should == '1'
   end
 
   it 'increments a key by given value' do
     @store.increment 'counter', 3
-    @store.read('counter').should == '3'
+    @store.read('counter', :raw => true).should == '3'
   end
 
   it 'decrements a key by given value' do
     3.times { @store.increment 'counter' }
     @store.decrement 'counter', 2
-    @store.read('counter').should == '1'
+    @store.read('counter', :raw => true).should == '1'
   end
 
   describe 'notifications' do

data/spec/generate.rb

@@ -3,24 +3,24 @@ class Specs
 
   def initialize(specs, key = nil, value = nil)
     @specs = specs
-    @key = key     || %w(Object String Hash Boolean Nil Integer)
-    @value = value || %w(Object String Hash Boolean Nil Integer)
+    @key = key     || %w(object string hash boolean nil integer)
+    @value = value || %w(object string hash boolean nil integer)
   end
 
   def stringkeys_only
-    Specs.new(specs, %w(String), value)
+    Specs.new(specs, %w(string), value)
   end
 
   def stringvalues_only
-    Specs.new(specs, key, %w(String))
+    Specs.new(specs, key, %w(string))
   end
 
   def simplekeys_only
-    Specs.new(specs, %w(String Hash Integer), value)
+    Specs.new(specs, %w(string hash integer), value)
   end
 
   def simplevalues_only
-    Specs.new(specs, key, %w(String Hash Integer))
+    Specs.new(specs, key, %w(string hash integer))
   end
 
   def without_increment
@@ -95,7 +95,7 @@ class Specs
   end
 end
 
-ADAPTER_SPECS = Specs.new([:null, :store, :returndifferent, :increment, :persist], %w(String), %w(String))
+ADAPTER_SPECS = Specs.new([:null, :store, :returndifferent, :increment, :persist], %w(string), %w(string))
 STANDARD_SPECS = Specs.new([:null, :store, :returndifferent, :marshallable_key, :marshallable_value, :transform_value, :increment, :persist])
 TRANSFORMER_SPECS = Specs.new([:null, :store, :returndifferent, :transform_value, :increment])
 
@@ -107,7 +107,7 @@ TESTS = {
     :store => :Client,
     :specs => STANDARD_SPECS,
     :tests => %{
-it 'should support multiple clients' do
+it 'supports multiple clients' do
   client = Moneta.new(:Client)
   client['shared_key'] = 'shared_val'
   (1..100).each do |i|
@@ -449,7 +449,7 @@ end
 end},
     :specs => STANDARD_SPECS.without_transform.with_expires.without_persist,
     :tests => %{
-it 'should support default expiration time' do
+it 'supports default expiration time' do
   store = Moneta.new(:Memory, :expires => 2)
   store.store('key1', 'val1')
   store.store('key2', 'val2', :expires => 60)
@@ -457,7 +457,7 @@ it 'should support default expiration time' do
   sleep 1
   store.load('key1').should == 'val1'
   sleep 2
-  store.load('key1').should == nil
+  store.load('key1').should be_nil
   store['key2'].should == 'val2'
 end}
   },
@@ -469,15 +469,15 @@ end}
 end},
     :specs => STANDARD_SPECS.with_expires.stringvalues_only,
     :tests => %{
-it 'should delete expired value in underlying file storage' do
+it 'deletes expired value in underlying file storage' do
   store.store('foo', 'bar', :expires => 2)
   store['foo'].should == 'bar'
   sleep 1
   store['foo'].should == 'bar'
   sleep 2
-  store['foo'].should == nil
-  store.adapter['foo'].should == nil
-  store.adapter.adapter['foo'].should == nil
+  store['foo'].should be_nil
+  store.adapter['foo'].should be_nil
+  store.adapter.adapter['foo'].should be_nil
 end
 }
   },
@@ -507,15 +507,15 @@ end},
 end},
     :specs => ADAPTER_SPECS,
     :tests => %{
-it 'should store loaded values in cache' do
+it 'stores loaded values in cache' do
   store.backend['foo'] = 'bar'
-  store.cache['foo'].should == nil
+  store.cache['foo'].should be_nil
   store['foo'].should == 'bar'
   store.cache['foo'].should == 'bar'
   store.backend.delete('foo')
   store['foo'].should == 'bar'
   store.delete('foo')
-  store['foo'].should == nil
+  store['foo'].should be_nil
 end
 }
   },
@@ -536,7 +536,7 @@ end},
 end},
     :specs => ADAPTER_SPECS.without_persist,
     :tests => %{
-it 'should share values' do
+it 'shares values' do
   store['shared_key'] = 'shared_value'
   second = new_store
   second.key?('shared_key').should be_true
@@ -678,10 +678,50 @@ end},
     :specs => TRANSFORMER_SPECS.simplekeys_only.simplevalues_only,
     :load_value => '::MessagePack.unpack(value)'
   },
+  'transformer_marshal' => {
+    :build => %{Moneta.build do
+  use :Transformer, :key => :marshal, :value => :marshal
+  adapter :Memory
+end},
+    :specs => TRANSFORMER_SPECS,
+    :load_value => '::Marshal.load(value)'
+  },
+  'transformer_key_marshal' => {
+    :build => %{Moneta.build do
+  use :Transformer, :key => :marshal
+  adapter :Memory
+end},
+    :specs => TRANSFORMER_SPECS,
+    :load_value => 'value'
+  },
+  'transformer_value_marshal' => {
+    :build => %{Moneta.build do
+  use :Transformer, :value => :marshal
+  adapter :Memory
+end},
+    :specs => TRANSFORMER_SPECS,
+    :load_value => '::Marshal.load(value)'
+  },
   'transformer_yaml' => {
     :build => %{Moneta.build do
   use :Transformer, :key => :yaml, :value => :yaml
   adapter :Memory
+end},
+    :specs => TRANSFORMER_SPECS,
+    :load_value => '::YAML.load(value)'
+  },
+  'transformer_key_yaml' => {
+    :build => %{Moneta.build do
+  use :Transformer, :key => :yaml
+  adapter :Memory
+end},
+    :specs => TRANSFORMER_SPECS,
+    :load_value => 'value'
+  },
+  'transformer_value_yaml' => {
+    :build => %{Moneta.build do
+  use :Transformer, :value => :yaml
+  adapter :Memory
 end},
     :specs => TRANSFORMER_SPECS,
     :load_value => '::YAML.load(value)'
@@ -808,7 +848,7 @@ end
     :build => "Moneta::Adapters::Cassandra.new(:keyspace => 'adapter_cassandra')",
     :specs => ADAPTER_SPECS.without_increment.with_expires,
     :tests => %{
-it 'should support default expiration time' do
+it 'supports default expiration time' do
   store = Moneta::Adapters::Cassandra.new(:expires => 2, :keyspace => 'adapter_cassandra')
   store.store('key1', 'val1')
   store.store('key2', 'val2', :expires => 60)
@@ -816,7 +856,7 @@ it 'should support default expiration time' do
   sleep 1
   store.load('key1').should == 'val1'
   sleep 2
-  store.load('key1').should == nil
+  store.load('key1').should be_nil
   store['key2'].should == 'val2'
 end}
   },
@@ -863,7 +903,7 @@ it 'does not cross contaminate when deleting' do
   second['key'] = 'value2'
 
   first.delete('key').should == 'value'
-  first.key?('key').should == false
+  first.key?('key').should be_false
   second['key'].should == 'value2'
 end
 }
@@ -897,7 +937,7 @@ end
     :build => 'Moneta::Adapters::MemcachedDalli.new(:namespace => "adapter_memcached_dalli")',
     :specs => ADAPTER_SPECS.with_expires,
     :tests => %{
-it 'should support default expiration time' do
+it 'supports default expiration time' do
   store = Moneta::Adapters::MemcachedDalli.new(:expires => 2, :namespace => "adapter_memcached_dalli")
   store.store('key1', 'val1')
   store.store('key2', 'val2', :expires => 60)
@@ -905,7 +945,7 @@ it 'should support default expiration time' do
   sleep 1
   store.load('key1').should == 'val1'
   sleep 2
-  store.load('key1').should == nil
+  store.load('key1').should be_nil
   store['key2'].should == 'val2'
 end}
   },
@@ -913,7 +953,7 @@ end}
     :build => 'Moneta::Adapters::MemcachedNative.new(:namespace => "adapter_memcached_native")',
     :specs => ADAPTER_SPECS.with_expires,
     :tests => %{
-it 'should support default expiration time' do
+it 'supports default expiration time' do
   store = Moneta::Adapters::MemcachedNative.new(:expires => 2, :namespace => "adapter_memcached_native")
   store.store('key1', 'val1')
   store.store('key2', 'val2', :expires => 60)
@@ -921,7 +961,7 @@ it 'should support default expiration time' do
   sleep 1
   store.load('key1').should == 'val1'
   sleep 2
-  store.load('key1').should == nil
+  store.load('key1').should be_nil
   store['key2'].should == 'val2'
 end
 }
@@ -930,7 +970,7 @@ end
     :build => 'Moneta::Adapters::Memcached.new(:namespace => "adapter_memcached")',
     :specs => ADAPTER_SPECS.with_expires,
     :tests => %{
-it 'should support default expiration time' do
+it 'supports default expiration time' do
   store = Moneta::Adapters::Memcached.new(:expires => 2, :namespace => "adapter_memcached")
   store.store('key1', 'val1')
   store.store('key2', 'val2', :expires => 60)
@@ -938,7 +978,7 @@ it 'should support default expiration time' do
   sleep 1
   store.load('key1').should == 'val1'
   sleep 2
-  store.load('key1').should == nil
+  store.load('key1').should be_nil
   store['key2'].should == 'val2'
 end}
   },
@@ -950,7 +990,7 @@ end}
     :build => 'Moneta::Adapters::LRUHash.new',
     :specs => ADAPTER_SPECS.without_persist,
     :tests => %{
-it 'should delete oldest' do
+it 'deletes oldest' do
   store = Moneta::Adapters::LRUHash.new(:max_size => 10)
   store[0]  = 'y'
   (1..1000).each do |i|
@@ -976,7 +1016,7 @@ end}
     :build => 'Moneta::Adapters::Redis.new',
     :specs => ADAPTER_SPECS.with_expires,
     :tests => %{
-it 'should support default expiration time' do
+it 'supports default expiration time' do
   store = Moneta::Adapters::Redis.new(:expires => 2)
   store.store('key1', 'val1')
   store.store('key2', 'val2', :expires => 60)
@@ -984,7 +1024,7 @@ it 'should support default expiration time' do
   sleep 1
   store.load('key1').should == 'val1'
   sleep 2
-  store.load('key1').should == nil
+  store.load('key1').should be_nil
   store['key2'].should == 'val2'
 end}
   },
@@ -1033,7 +1073,7 @@ it '#with should return OptionMerger' do
   merger.should be_instance_of(Moneta::OptionMerger)
 end
 
-it 'should save default options' do
+it 'saves default options' do
   options = {:optionname => :optionvalue}
   merger = store.with(options)
   Moneta::OptionMerger::METHODS.each do |method|
@@ -1043,14 +1083,14 @@ end
 
 PREFIX = [['alpha', nil], ['beta', nil], ['alpha', 'beta']]
 
-it 'should merge options' do
+it 'merges options' do
   merger = store.with(:opt1 => :val1, :opt2 => :val2).with(:opt2 => :overwrite, :opt3 => :val3)
   Moneta::OptionMerger::METHODS.each do |method|
     merger.default_options[method].should == {:opt1 => :val1, :opt2 => :overwrite, :opt3 => :val3}
   end
 end
 
-it 'should merge options only for some methods' do
+it 'merges options only for some methods' do
   PREFIX.each do |(alpha,beta)|
     options = {:opt1 => :val1, :opt2 => :val2, :prefix => alpha}
     merger = store.with(options).with(:opt2 => :overwrite, :opt3 => :val3, :prefix => beta, :only => :clear)
@@ -1068,7 +1108,7 @@ it 'should merge options only for some methods' do
   end
 end
 
-it 'should merge options except for some methods' do
+it 'merges options except for some methods' do
   PREFIX.each do |(alpha,beta)|
     options = {:opt1 => :val1, :opt2 => :val2, :prefix => alpha}
     merger = store.with(options).with(:opt2 => :overwrite, :opt3 => :val3, :except => :clear, :prefix => beta)
@@ -1086,12 +1126,12 @@ it 'should merge options except for some methods' do
   end
 end
 
-it 'should have method #raw' do
+it 'has method #raw' do
   store.raw.default_options.should == {:store=>{:raw=>true},:load=>{:raw=>true},:delete=>{:raw=>true}}
   store.raw.should equal(store.raw.raw)
 end
 
-it 'should have method #prefix' do
+it 'has method #prefix' do
   store.prefix('a').default_options.should == {:store=>{:prefix=>'a'},:load=>{:prefix=>'a'},
                                                :delete=>{:prefix=>'a'},:key? => {:prefix=>'a'},:increment=>{:prefix=>'a'}}
 
@@ -1110,122 +1150,100 @@ end}
 SPECS = {}
 
 KEYS = {
-  'Nil' => [0, 'nil'],
-  'Integer' => [-10, 42],
-  'Boolean' => [true, false],
-  'String' => ['strkey1', 'strkey2'].map(&:inspect),
-  'Object' => ['Value.new(:objkey1)', 'Value.new(:objkey2)'],
-  'Hash' => [{'hashkey1' => 'hashkey2'}, {'hashkey3' => 'hashkey4'}].map(&:inspect)
+  'nil' => [0, 'nil'],
+  'integer' => [-10, 42],
+  'boolean' => [true, false],
+  'string' => ['strkey1', 'strkey2'].map(&:inspect),
+  'object' => ['Value.new(:objkey1)', 'Value.new(:objkey2)'],
+  'hash' => [{'hashkey1' => 'hashkey2'}, {'hashkey3' => 'hashkey4'}].map(&:inspect)
 }
 
 VALUES = {
-  'Nil' => [0, 'nil'],
-  'Integer' => [41, -12],
-  'Boolean' => [false, true],
-  'String' => ['strval1', 'strval2'].map(&:inspect),
-  'Hash' => [{'hashval1' => ['array1', 1]}, {'hashval3' => ['array2', {'hashval4' => 42}]}].map(&:inspect),
-  'Object' => ['Value.new(:objval1)', 'Value.new(:objval2)'],
+  'nil' => [0, 'nil'],
+  'integer' => [41, -12],
+  'boolean' => [true, false],
+  'string' => ['strval1', 'strval2'].map(&:inspect),
+  'hash' => [{'hashval1' => ['array1', 1]}, {'hashval3' => ['array2', {'hashval4' => 42}]}].map(&:inspect),
+  'object' => ['Value.new(:objval1)', 'Value.new(:objval2)'],
 }
 
-KEYS.each do |key_type, (key1,key2)|
-  VALUES.each do |val_type, (val1,val2)|
+KEYS.each do |key_type, keypair|
+  VALUES.each do |val_type, valpair|
+    4.times do |i|
+      key1, key2 = i % 2 == 0 ? keypair : keypair.reverse
+      val1, val2 = i < 2 ? valpair : valpair.reverse
 
-    code = %{it "reads from keys that are #{key_type}s like a Hash" do
-  store[#{key1}].should == nil
-  store.load(#{key1}).should == nil
-
-  store[#{key2}].should == nil
-  store.load(#{key2}).should == nil
+      code = %{it 'reads from keys like a Hash' do
+  store[#{key1}].should be_nil
+  store.load(#{key1}).should be_nil
 end
 
-it "guarantees that the same #{val_type} value is returned when setting a #{key_type} key" do
+it 'guarantees that the same value is returned when setting a key' do
   value = #{val1}
   (store[#{key1}] = value).should equal(value)
-
-  value = #{val2}
-  (store[#{key2}] = value).should equal(value)
 end
 
-it "returns false from key? if a #{key_type} key is not available" do
-  store.key?(#{key1}).should == false
-  store.key?(#{key2}).should == false
+it 'returns false from key? if a key is not available' do
+  store.key?(#{key1}).should be_false
 end
 
-it "returns nil from delete if an element for a #{key_type} key does not exist" do
-  store.delete(#{key1}).should == nil
-  store.delete(#{key2}).should == nil
+it 'returns nil from delete if a value for a key does not exist' do
+  store.delete(#{key1}).should be_nil
 end
 
-it "removes all #{key_type} keys from the store with clear" do
+it 'removes all keys from the store with clear' do
   store[#{key1}] = #{val1}
   store[#{key2}] = #{val2}
   store.clear.should equal(store)
-  store.key?(#{key1}).should_not ==  true
-  store.key?(#{key2}).should_not == true
+  store.key?(#{key1}).should be_false
+  store.key?(#{key2}).should be_false
 end
 
-it "fetches a #{key_type} key with a default value with fetch, if the key is not available" do
+it 'fetches a key with a default value with fetch, if the key is not available' do
   store.fetch(#{key1}, #{val1}).should == #{val1}
-  store.fetch(#{key2}, #{val2}).should == #{val2}
 end
 
-it "fetches a #{key_type} key with a block with fetch, if the key is not available" do
+it 'fetches a key with a block with fetch, if the key is not available' do
   key = #{key1}
   value = #{val1}
   store.fetch(key) do |k|
     k.should equal(key)
     value
   end.should equal(value)
-
-  key = #{key2}
-  value = #{val2}
-  store.fetch(key) do |k|
-    k.should equal(key)
-    value
-  end.should equal(value)
 end
 
-it 'should accept options' do
-  store.key?(#{key1}, :option1 => 1).should == false
-  store.load(#{key1}, :option2 => 2).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}
+it 'accepts frozen options' do
+  options = {:option1 => 1, :options2 => 2}
+  options.freeze
+  store.key?(#{key1}, options).should be_false
+  store.load(#{key1}, options).should be_nil
+  store.fetch(#{key1}, 42, options).should == 42
+  store.fetch(#{key1}, options) { 42 }.should == 42
+  store.delete(#{key1}, options).should be_nil
+  store.clear(options).should equal(store)
+  store.store(#{key1}, #{val1}, options).should == #{val1}
 end}
-    SPECS["null_#{key_type.downcase}key_#{val_type.downcase}value"] = code
+    (SPECS["null_#{key_type}key_#{val_type}value"] ||= []) << code
 
-    code = %{it "writes #{val_type} values to keys that are #{key_type}s like a Hash" do
+    code = %{it 'writes values to keys that like a Hash' do
   store[#{key1}] = #{val1}
   store[#{key1}].should == #{val1}
   store.load(#{key1}).should == #{val1}
-
-  store[#{key2}] = #{val2}
-  store[#{key2}].should == #{val2}
-  store.load(#{key2}).should == #{val2}
 end
 
-it "returns true from key? if a #{key_type} key is available" do
+it 'returns true from key? if a key is available' do
   store[#{key1}] = #{val1}
-  store.key?(#{key1}).should == true
-  store[#{key2}] = #{val2}
-  store.key?(#{key2}).should == true
+  store.key?(#{key1}).should be_true
 end
 
-it "stores #{val_type} values with #{key_type} keys with #store" do
+it 'stores values with #store' do
   value = #{val1}
   store.store(#{key1}, value).should equal(value)
   store[#{key1}].should == #{val1}
   store.load(#{key1}).should == #{val1}
-
-  value = #{val2}
-  store.store(#{key2}, value).should equal(value)
-  store[#{key2}].should == #{val2}
-  store.load(#{key2}).should == #{val2}
 end
 
-it "stores #{key_type} after clear" do
+it 'stores values after clear' do
   store[#{key1}] = #{val1}
   store[#{key2}] = #{val2}
   store.clear.should equal(store)
@@ -1234,72 +1252,57 @@ it "stores #{key_type} after clear" do
   store[#{key2}].should be_nil
 end
 
-it "removes and returns a #{val_type} element with a #{key_type} key from the backing store via delete if it exists" do
+it 'removes and returns a value from the backing store via delete if it exists' do
   store[#{key1}] = #{val1}
   store.delete(#{key1}).should == #{val1}
-  store.key?(#{key1}).should == false
-
-  store[#{key2}] = #{val2}
-  store.delete(#{key2}).should == #{val2}
-  store.key?(#{key2}).should == false
+  store.key?(#{key1}).should be_false
 end
 
-it "overwrites existing #{val_type} values with #{key_type}" do
+it 'overwrites existing values' do
   store[#{key1}] = #{val1}
   store[#{key1}].should == #{val1}
   store[#{key1}] = #{val2}
   store[#{key1}].should == #{val2}
-end
+end}
 
-it "fetches a #{key_type} key with a default value with fetch, if the key is available" do
+      if val_type != 'nil'
+        code << %{
+it 'fetches a key with a default value with fetch, if the key is available' do
   store[#{key1}] = #{val1}
   store.fetch(#{key1}, #{val2}).should == #{val1}
-end}
+end
 
-    if val_type != 'Nil'
-      code << %{
-it "does not run the block if the #{key_type} key is available" do
+it 'does not run the block in fetch if the key is available' do
   store[#{key1}] = #{val1}
   unaltered = 'unaltered'
   store.fetch(#{key1}) { unaltered = 'altered' }
   unaltered.should == 'unaltered'
-
-  store[#{key2}] = #{val2}
-  unaltered = 'unaltered'
-  store.fetch(#{key2}) { unaltered = 'altered' }
-  unaltered.should == 'unaltered'
 end}
-    end
+      end
 
-    SPECS["store_#{key_type.downcase}key_#{val_type.downcase}value"] = code
+      (SPECS["store_#{key_type}key_#{val_type}value"] ||= []) << code
 
-    code = %{it "guarantees that a different #{val_type} value is retrieved from the #{key_type} key" do
+      code = %{it 'guarantees that a different value is retrieved' do
   value = #{val1}
   store[#{key1}] = #{val1}
   store[#{key1}].should_not be_equal(#{val1})
-
-  value = #{val2}
-  store[#{key2}] = #{val2}
-  store[#{key2}].should_not be_equal(#{val2})
 end}
-    if val_type != 'Boolean' && val_type != 'Nil' && val_type != 'Integer'
-      SPECS["returndifferent_#{key_type.downcase}key_#{val_type.downcase}value"] = code
-    end
+      if val_type != 'boolean' && val_type != 'nil' && val_type != 'integer'
+        (SPECS["returndifferent_#{key_type}key_#{val_type}value"] ||= []) << code
+      end
 
-    code = %{it "persists #{val_type} values with #{key_type} keys" do
+      code = %{it 'persists values' do
   store[#{key1}] = #{val1}
-  store[#{key2}] = #{val2}
   store.close
   @store = nil
-
   store[#{key1}].should == #{val1}
-  store[#{key2}].should == #{val2}
 end}
-    SPECS["persist_#{key_type.downcase}key_#{val_type.downcase}value"] = code
+      (SPECS["persist_#{key_type}key_#{val_type}value"] ||= []) << code
+    end
   end
 end
 
-SPECS['not_persist'] = %{it "does not persist values" do
+SPECS['not_persist'] = %{it 'does not persist values' do
   store['key'] = 'val'
   store.close
   @store = nil
@@ -1307,34 +1310,34 @@ SPECS['not_persist'] = %{it "does not persist values" do
   store['key'].should be_nil
 end}
 
-SPECS['expires'] = %{it 'should support expires on store and #[]' do
+SPECS['expires'] = %{it 'supports expires on store and #[]' do
   store.store('key1', 'val1', :expires => 2)
   store['key1'].should == 'val1'
   sleep 1
   store['key1'].should == 'val1'
   sleep 2
-  store['key1'].should == nil
+  store['key1'].should be_nil
 end
 
-it 'should support expires on store and load' do
+it 'supports expires on store and load' do
   store.store('key1', 'val1', :expires => 2)
   store.load('key1').should == 'val1'
   sleep 1
   store.load('key1').should == 'val1'
   sleep 2
-  store.load('key1').should == nil
+  store.load('key1').should be_nil
 end
 
-it 'should support expires on store and key?' do
+it 'supports expires on store and key?' do
   store.store('key1', 'val1', :expires => 2)
-  store.key?('key1').should == true
+  store.key?('key1').should be_true
   sleep 1
-  store.key?('key1').should == true
+  store.key?('key1').should be_true
   sleep 2
-  store.key?('key1').should == false
+  store.key?('key1').should be_false
 end
 
-it 'should support updating the expiration time in load' do
+it 'supports updating the expiration time in load' do
   store.store('key2', 'val2', :expires => 2)
   store['key2'].should == 'val2'
   sleep 1
@@ -1343,10 +1346,10 @@ it 'should support updating the expiration time in load' do
   sleep 1
   store['key2'].should == 'val2'
   sleep 3
-  store['key2'].should == nil
+  store['key2'].should be_nil
 end
 
-it 'should support updating the expiration time in key?' do
+it 'supports updating the expiration time in key?' do
   store.store('key2', 'val2', :expires => 2)
   store['key2'].should == 'val2'
   sleep 1
@@ -1355,10 +1358,10 @@ it 'should support updating the expiration time in key?' do
   sleep 1
   store['key2'].should == 'val2'
   sleep 3
-  store['key2'].should == nil
+  store['key2'].should be_nil
 end
 
-it 'should support updating the expiration time in fetch' do
+it 'supports updating the expiration time in fetch' do
   store.store('key1', 'val1', :expires => 2)
   store['key1'].should == 'val1'
   sleep 1
@@ -1367,42 +1370,42 @@ it 'should support updating the expiration time in fetch' do
   sleep 1
   store['key1'].should == 'val1'
   sleep 3
-  store['key1'].should == nil
+  store['key1'].should be_nil
 end
 
-it 'should respect expires in delete' do
+it 'respects expires in delete' do
   store.store('key2', 'val2', :expires => 2)
   store['key2'].should == 'val2'
   sleep 1
   store['key2'].should == 'val2'
   sleep 2
-  store.delete('key2').should == nil
+  store.delete('key2').should be_nil
 end
 
-it 'should support the #expires syntactic sugar' do
+it 'supports the #expires syntactic sugar' do
   store['longlive_key'] = 'longlive_value'
   store.expires(2).store('key2', 'val2')
   store['key2'].should == 'val2'
   sleep 1
   store['key2'].should == 'val2'
   sleep 2
-  store.delete('key2').should == nil
+  store.delete('key2').should be_nil
   store['longlive_key'].should == 'longlive_value'
 end}
 
-SPECS['not_increment'] = %{it 'should not support #increment' do
+SPECS['not_increment'] = %{it 'does not support #increment' do
   expect do
     store.increment('inckey')
   end.to raise_error(NotImplementedError)
 end
 
-it 'should not support #decrement' do
+it 'does not support #decrement' do
   expect do
     store.increment('inckey')
   end.to raise_error(NotImplementedError)
 end}
 
-SPECS['increment'] = %{it 'should initialize in #increment with 1' do
+SPECS['increment'] = %{it 'initializes in #increment with 1' do
   store.key?('inckey').should be_false
   store.increment('inckey').should == 1
   store.key?('inckey').should be_true
@@ -1410,65 +1413,41 @@ SPECS['increment'] = %{it 'should initialize in #increment with 1' do
   store.raw.load('inckey').should == '1'
   store.load('inckey', :raw => true).should == '1'
 
-  # WARNING: Undefined behaviour!
-  result = safe_load_value(store.raw['inckey'])
-  store['inckey'].should == result
-
   store.delete('inckey', :raw => true).should == '1'
   store.key?('inckey').should be_false
 end
 
-it 'should initialize in #increment with higher value' do
+it 'initializes in #increment with higher value' do
   store.increment('inckey', 42).should == 42
   store.key?('inckey').should be_true
   store.raw['inckey'].should == '42'
-
-  # WARNING: Undefined behaviour!
-  result = safe_load_value(store.raw['inckey'])
-  store['inckey'].should == result
-
   store.delete('inckey', :raw => true).should == '42'
 end
 
-it 'should initialize in #increment with 0' do
+it 'initializes in #increment with 0' do
   store.increment('inckey', 0).should == 0
   store.key?('inckey').should be_true
   store.raw['inckey'].should == '0'
-
-  # WARNING: Undefined behaviour!
-  result = safe_load_value(store.raw['inckey'])
-  store['inckey'].should == result
-
   store.delete('inckey', :raw => true).should == '0'
 end
 
-it 'should support deleting integer value' do
-  store.increment('inckey').should == 1
-
-  # WARNING: Undefined behaviour!
-  result = safe_load_value(store.raw['inckey'])
-  store.delete('inckey').should == result
-
-  store.key?('inckey').should be_false
-end
-
-it 'should initialize in #decrement with 0' do
+it 'initializes in #decrement with 0' do
   store.decrement('inckey', 0).should == 0
   store.raw['inckey'].should == '0'
 end
 
-it 'should initialize in #decrement with negative value' do
+it 'initializes in #decrement with negative value' do
   store.decrement('inckey', -42).should == 42
   store.raw['inckey'].should == '42'
 end
 
-it 'should support incrementing existing value by value' do
+it 'supports incrementing existing value by value' do
   store.increment('inckey').should == 1
   store.increment('inckey', 42).should == 43
   store.raw['inckey'].should == '43'
 end
 
-it 'should support decrementing existing value by value' do
+it 'supports decrementing existing value by value' do
   store.increment('inckey').should == 1
   store.decrement('inckey').should == 0
   store.increment('inckey', 42).should == 42
@@ -1476,13 +1455,13 @@ it 'should support decrementing existing value by value' do
   store.raw['inckey'].should == '40'
 end
 
-it 'should support incrementing existing value by 0' do
+it 'supports incrementing existing value by 0' do
   store.increment('inckey').should == 1
   store.increment('inckey', 0).should == 1
   store.raw['inckey'].should == '1'
 end
 
-it 'should support decrementing existing value' do
+it 'supports decrementing existing value' do
   store.increment('inckey', 10).should == 10
   store.increment('inckey', -5).should == 5
   store.raw['inckey'].should == '5'
@@ -1490,20 +1469,20 @@ it 'should support decrementing existing value' do
   store.raw['inckey'].should == '0'
 end
 
-it 'interpret raw value as integer' do
+it 'interprets raw value as integer' do
   store.store('inckey', '42', :raw => true)
   store.increment('inckey').should == 43
   store.raw['inckey'].should == '43'
 end
 
-it 'should raise error in #increment on non integer value' do
+it 'raises error in #increment on non integer value' do
   store['strkey'] = 'value'
   expect do
     store.increment('strkey')
   end.to raise_error
 end
 
-it 'should raise error in #decrement on non integer value' do
+it 'raises error in #decrement on non integer value' do
   store['strkey'] = 'value'
   expect do
     store.decrement('strkey')
@@ -1580,16 +1559,36 @@ it 'allows to bypass transformer with raw syntactic sugar' do
   store.raw['key'].should == 'value2'
 end
 
-it 'should return unmarshalled value' do
+it 'returns unmarshalled value' do
   store.store('key', 'unmarshalled value', :raw => true)
   store.load('key', :raw => true).should == 'unmarshalled value'
-  store['key'].should == 'unmarshalled value'
-  store.delete('key').should == 'unmarshalled value'
+end
+
+it 'might raise exception on invalid value' do
+  store.store('key', 'unmarshalled value', :raw => true)
+
+  begin
+    store['key'].should == load_value('unmarshalled value')
+    store.delete('key').should == load_value('unmarshalled value')
+  rescue Exception => ex
+    expect do
+      store['key']
+    end.to raise_error
+    expect do
+      store.delete('key')
+    end.to raise_error
+  end
 end}
 
 SPECS['transform_value_with_expires']  = %{it 'allows to bypass transformer with :raw' do
   store['key'] = 'value'
-  load_value(store.load('key', :raw => true)).should == ['value']
+  load_value(store.load('key', :raw => true)).should == 'value'
+  store['key'] = [1,2,3]
+  load_value(store.load('key', :raw => true)).should == [[1,2,3]]
+  store['key'] = nil
+  load_value(store.load('key', :raw => true)).should == [nil]
+  store['key'] = false
+  load_value(store.load('key', :raw => true)).should be_false
 
   store.store('key', 'value', :expires => 10)
   load_value(store.load('key', :raw => true)).first.should == 'value'
@@ -1600,17 +1599,31 @@ SPECS['transform_value_with_expires']  = %{it 'allows to bypass transformer with
   store.delete('key', :raw => true).should == 'value'
 end
 
-it 'should return unmarshalled value' do
+it 'returns unmarshalled value' do
   store.store('key', 'unmarshalled value', :raw => true)
   store.load('key', :raw => true).should == 'unmarshalled value'
-  store['key'].should == 'unmarshalled value'
-  store.delete('key').should == 'unmarshalled value'
+end
+
+it 'might raise exception on invalid value' do
+  store.store('key', 'unmarshalled value', :raw => true)
+
+  begin
+    store['key'].should == load_value('unmarshalled value')
+    store.delete('key').should == load_value('unmarshalled value')
+  rescue Exception => ex
+    expect do
+      store['key']
+    end.to raise_error
+    expect do
+      store.delete('key')
+    end.to raise_error
+  end
 end}
 
 specs_code = "#{header}\n"
 SPECS.each do |key, code|
   specs_code << "#################### #{key} ####################\n\n" <<
-    "shared_examples_for '#{key}' do\n  " << code.gsub("\n", "\n  ") << "\nend\n\n"
+    "shared_examples_for '#{key}' do\n  " << [code].flatten.join("\n\n").gsub("\n", "\n  ") << "\nend\n\n"
 end
 specs_code.gsub!(/\n +\n/, "\n\n")
 File.open(File.join(File.dirname(__FILE__), 'monetaspecs.rb'), 'w') {|out| out << specs_code }
@@ -1627,7 +1640,7 @@ TESTS.each do |name, options|
     specs_code << "  it_should_behave_like '#{s}'" if SPECS[s.to_s]
     specs.key.each do |k|
       specs.value.each do |v|
-        x = "#{s}_#{k.downcase}key_#{v.downcase}value"
+        x = "#{s}_#{k}key_#{v}value"
         specs_code << "  it_should_behave_like '#{x}'" if SPECS[x]
       end
     end