moneta 1.2.1 → 1.3.0

data/lib/moneta/shared.rb

@@ -11,8 +11,6 @@ module Moneta
   #
   # @api public
   class Shared < Wrapper
-    not_supports :each_key
-
     # @param [Hash] options
     # @option options [Integer] :port (9000) TCP port
     # @option options [String] :host Server hostname
@@ -25,7 +23,7 @@ module Moneta
 
     # (see Proxy#close)
     def close
-      if @server
+      if server?
         @server.stop
         @thread.join
         @server = @thread = nil
@@ -36,13 +34,20 @@ module Moneta
       end
     end
 
+    # Returns true if this wrapper is running as the server
+    #
+    # @return [Boolean] wrapper is a server
+    def server?
+      @server != nil
+    end
+
     protected
 
     def wrap(*args)
       connect
       yield
     rescue Errno::ECONNRESET, Errno::EPIPE, IOError, SystemCallError
-      @connect_lock.synchronize { close unless @server }
+      @connect_lock.synchronize { close unless server? }
       tries ||= 0
       (tries += 1) < 3 ? retry : raise
     end
@@ -52,21 +57,22 @@ module Moneta
       @connect_lock.synchronize do
         @adapter ||= Adapters::Client.new(@options)
       end
-    rescue Errno::ECONNREFUSED, Errno::ENOENT => ex
+    rescue Errno::ECONNREFUSED, Errno::ENOENT, IOError => ex
       start_server
       tries ||= 0
       warn "Moneta::Shared - Failed to connect: #{ex.message}" if tries > 0
-      (tries += 1) < 3 ? retry : raise
+      (tries += 1) < 10 ? retry : raise
     end
 
     # TODO: Implement this using forking (MRI) and threading (JRuby)
     # to get maximal performance
     def start_server
       @connect_lock.synchronize do
+        return if server?
         begin
           raise "Adapter already set" if @adapter
           @adapter = Lock.new(@builder.build.last)
-          raise "Server already set" if @server
+          raise "Server already set" if server?
           @server = Server.new(@adapter, @options)
           @thread = Thread.new { @server.run }
           sleep 0.1 until @server.running?

data/lib/moneta/transformer.rb

@@ -43,12 +43,15 @@ module Moneta
 
       def compile(keys, values)
         @key_validator ||= compile_validator(KEY_TRANSFORMER)
+        @load_key_validator ||= compile_validator(LOAD_KEY_TRANSFORMER)
+        @test_key_validator ||= compile_validator(TEST_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
 
         klass = Class.new(self)
+        compile_each_key_support_clause(klass, keys)
         klass.class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
           def initialize(adapter, options = {})
             super
@@ -58,15 +61,17 @@ module Moneta
         END_EVAL
 
         key, key_opts = compile_transformer(keys, 'key')
+        key_load, key_load_opts = compile_transformer(keys.reverse, 'key', 1) if @load_key_validator =~ keys.map(&:inspect).join
+        key_test, key_test_opts = compile_transformer(keys.reverse, 'key', 4) if @test_key_validator =~ keys.map(&:inspect).join
         dump, dump_opts = compile_transformer(values, 'value')
         load, load_opts = compile_transformer(values.reverse, 'value', 1)
 
         if values.empty?
-          compile_key_transformer(klass, key, key_opts)
+          compile_key_transformer(klass, key, key_opts, key_load, key_load_opts, key_test, key_test_opts)
         elsif keys.empty?
           compile_value_transformer(klass, load, load_opts, dump, dump_opts)
         else
-          compile_key_value_transformer(klass, key, key_opts, load, load_opts, dump, dump_opts)
+          compile_key_value_transformer(klass, key, key_opts, key_load, key_load_opts, key_test, key_test_opts, load, load_opts, dump, dump_opts)
         end
 
         klass
@@ -77,13 +82,28 @@ module Moneta
         options.empty? ? 'options' : "Utils.without(options, #{options.map(&:to_sym).map(&:inspect).join(', ')})"
       end
 
-      def compile_key_transformer(klass, key, key_opts)
+      def compile_each_key_support_clause(klass, keys)
         klass.class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
-          not_supports :each_key
+          #{'not_supports :each_key' if @load_key_validator !~ keys.map(&:inspect).join}
+        END_EVAL
+      end
+
+      def compile_key_transformer(klass, key, key_opts, key_load, key_load_opts, key_test, key_test_opts)
+        if_key_test = key_load && key_test ? "if #{key_test}" : ''
 
+        klass.class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
           def key?(key, options = {})
             @adapter.key?(#{key}, #{without key_opts})
           end
+          def each_key(&block)
+            raise NotImplementedError, "each_key is not supported on this transformer" \
+              unless supports? :each_key
+
+            return enum_for(:each_key) unless block_given?
+            @adapter.each_key.lazy.map{ |key| #{key_load} #{if_key_test} }.reject(&:nil?).each(&block)
+
+            self
+          end
           def increment(key, amount = 1, options = {})
             @adapter.increment(#{key}, amount, #{without key_opts})
           end
@@ -200,13 +220,22 @@ module Moneta
         END_EVAL
       end
 
-      def compile_key_value_transformer(klass, key, key_opts, load, load_opts, dump, dump_opts)
-        klass.class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
-          not_supports :each_key
+      def compile_key_value_transformer(klass, key, key_opts, key_load, key_load_opts, key_test, key_test_opts, load, load_opts, dump, dump_opts)
+        if_key_test = key_load && key_test ? "if #{key_test}" : ''
 
+        klass.class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
           def key?(key, options = {})
             @adapter.key?(#{key}, #{without key_opts})
           end
+          def each_key(&block)
+            raise NotImplementedError, "each_key is not supported on this transformer" \
+              unless supports? :each_key
+
+            return enum_for(:each_key) { @adapter.each_key.size } unless block_given?
+            @adapter.each_key.lazy.map{ |key| #{key_load} #{if_key_test} }.reject(&:nil?).each(&block)
+
+            self
+          end
           def increment(key, amount = 1, options = {})
             @adapter.increment(#{key}, amount, #{without key_opts})
           end
@@ -320,9 +349,15 @@ module Moneta
           raise ArgumentError, "Unknown transformer #{name}" unless t = TRANSFORMER[name]
           require t[3] if t[3]
           code = t[idx]
+          code ||= compile_prefix(name: name, transformer: t, value: value) if idx == 4 && var == 'key'
+
+          raise "Undefined command for transformer #{name}" unless code
+
           options += code.scan(/options\[:(\w+)\]/).flatten
           value =
-            if t[0] == :serialize && var == 'key'
+            if t[0] == :serialize && var == 'key' && idx == 4
+              "(tmp = #{value}; (false === tmp || '' === tmp) ? false : #{code % 'tmp'})"
+            elsif t[0] == :serialize && var == 'key'
               "(tmp = #{value}; String === tmp ? tmp : #{code % 'tmp'})"
             else
               code % value
@@ -336,6 +371,13 @@ module Moneta
         (keys.empty? ? '' : keys.map(&camel_case).join + 'Key') +
           (values.empty? ? '' : values.map(&camel_case).join + 'Value')
       end
+
+      def compile_prefix(name:, transformer:, value:)
+        return unless [:encode, :serialize].include?(transformer[0])
+
+        load_val, = compile_transformer([name], value, 1)
+        "(#{load_val} rescue '')"
+      end
     end
   end
 end

data/lib/moneta/transformer/config.rb

@@ -2,48 +2,61 @@ module Moneta
   class Transformer
     # Available key/value transformers
     TRANSFORMER = {
-      # Name:   [ Type,       Load,                           Dump,                              Library         ],
-      bencode:  [ :serialize, '::BEncode.load(%s)',           '::BEncode.dump(%s)',              'bencode'       ],
-      bert:     [ :serialize, '::BERT.decode(%s)',            '::BERT.encode(%s)',               'bert'          ],
-      bson:     [ :serialize, 'Helper::BSON.load(%s)',        'Helper::BSON.dump(%s)',           'bson'          ],
-      json:     [ :serialize, '::MultiJson.load(%s)',         '::MultiJson.dump(%s)',            'multi_json'    ],
-      marshal:  [ :serialize, '::Marshal.load(%s)',           '::Marshal.dump(%s)'                               ],
-      msgpack:  [ :serialize, '::MessagePack.unpack(%s)',     '::MessagePack.pack(%s)',          'msgpack'       ],
-      ox:       [ :serialize, '::Ox.parse_obj(%s)',           '::Ox.dump(%s)',                   'ox'            ],
-      php:      [ :serialize, '::PHP.unserialize(%s)',        '::PHP.serialize(%s)',           'php_serialize' ],
-      tnet:     [ :serialize, '::TNetstring.parse(%s).first', '::TNetstring.dump(%s)',           'tnetstring'    ],
-      yaml:     [ :serialize, '::YAML.load(%s)',              '::YAML.dump(%s)',                 'yaml'          ],
-      bzip2:    [ :compress,  'Helper.bunzip2(%s)',           'Helper.bzip2(%s)',                'rbzip2'        ],
-      lz4:      [ :compress,  '::LZ4.uncompress(%s)',         '::LZ4.compress(%s)',              'lz4-ruby'      ],
-      lzma:     [ :compress,  '::LZMA.decompress(%s)',        '::LZMA.compress(%s)',             'lzma'          ],
-      lzo:      [ :compress,  '::LZO.decompress(%s)',         '::LZO.compress(%s)',              'lzoruby'       ],
-      snappy:   [ :compress,  '::Snappy.inflate(%s)',         '::Snappy.deflate(%s)',            'snappy'        ],
-      quicklz:  [ :compress,  '::QuickLZ.decompress(%s)',     '::QuickLZ.compress(%s)',          'qlzruby'       ],
-      zlib:     [ :compress,  '::Zlib::Inflate.inflate(%s)',  '::Zlib::Deflate.deflate(%s)',     'zlib'          ],
-      base64:   [ :encode,    "%s.unpack('m0').first",        "[%s].pack('m0')"                                  ],
+      # Name:   [ Type,       Load,                           Dump,                              Library        Test      ],
+      bencode:  [ :serialize, '::BEncode.load(%s)',           '::BEncode.dump(%s)',              'bencode'      ],
+      bert:     [ :serialize, '::BERT.decode(%s)',            '::BERT.encode(%s)',               'bert'         ],
+      bson:     [ :serialize, 'Helper::BSON.load(%s)',        'Helper::BSON.dump(%s)',           'bson'         ],
+      json:     [ :serialize, '::MultiJson.load(%s)',         '::MultiJson.dump(%s)',            'multi_json'   ],
+      marshal:  [ :serialize, '::Marshal.load(%s)',           '::Marshal.dump(%s)',              nil            ],
+      msgpack:  [ :serialize, '::MessagePack.unpack(%s)',     '::MessagePack.pack(%s)',          'msgpack'      ],
+      ox:       [ :serialize, '::Ox.parse_obj(%s)',           '::Ox.dump(%s)',                   'ox'           ],
+      php:      [ :serialize, '::PHP.unserialize(%s)',        '::PHP.serialize(%s)',             'php_serialize'],
+      tnet:     [ :serialize, '::TNetstring.parse(%s).first', '::TNetstring.dump(%s)',           'tnetstring'   ],
+      yaml:     [ :serialize, '::YAML.load(%s)',              '::YAML.dump(%s)',                 'yaml'         ],
+      bzip2:    [ :compress,  'Helper.bunzip2(%s)',           'Helper.bzip2(%s)',                'rbzip2'       ],
+      lz4:      [ :compress,  '::LZ4.uncompress(%s)',         '::LZ4.compress(%s)',              'lz4-ruby'     ],
+      lzma:     [ :compress,  '::LZMA.decompress(%s)',        '::LZMA.compress(%s)',             'lzma'         ],
+      lzo:      [ :compress,  '::LZO.decompress(%s)',         '::LZO.compress(%s)',              'lzoruby'      ],
+      snappy:   [ :compress,  '::Snappy.inflate(%s)',         '::Snappy.deflate(%s)',            'snappy'       ],
+      quicklz:  [ :compress,  '::QuickLZ.decompress(%s)',     '::QuickLZ.compress(%s)',          'qlzruby'      ],
+      zlib:     [ :compress,  '::Zlib::Inflate.inflate(%s)',  '::Zlib::Deflate.deflate(%s)',     'zlib'         ],
+      base64:   [ :encode,    "%s.unpack('m0').first",        "[%s].pack('m0')"                                 ],
       urlsafe_base64: [
-        :encode,              'Base64.urlsafe_decode64(%s)',  'Base64.urlsafe_encode64(%s)',     'base64'
+        :encode,
+        'Base64.urlsafe_decode64(%s)',
+        'Base64.urlsafe_encode64(%s)',
+        'base64'
       ],
-      escape:   [ :encode,    'Helper.unescape(%s)',          'Helper.escape(%s)'                                ],
-      hex:      [ :encode,    "[%s].pack('H*')",              "%s.unpack('H*').first"                            ],
-      qp:       [ :encode,    "%s.unpack('M').first",         "[%s].pack('M')"                                   ],
-      uuencode: [ :encode,    "%s.unpack('u').first",         "[%s].pack('u')"                                   ],
-      hmac:     [ :hmac,      'Helper.hmacverify(%s, options[:secret] || @secret)',
-                                 'Helper.hmacsign(%s, options[:secret] || @secret)',                'openssl'       ],
-      truncate: [ :truncate,  nil,                            'Helper.truncate(%s, @maxlen)',    'digest/md5'    ],
-      md5:      [ :digest,    nil,                            '::Digest::MD5.hexdigest(%s)',     'digest/md5'    ],
-      rmd160:   [ :digest,    nil,                            '::Digest::RMD160.hexdigest(%s)',  'digest/rmd160' ],
-      sha1:     [ :digest,    nil,                            '::Digest::SHA1.hexdigest(%s)',    'digest/sha1'   ],
-      sha256:   [ :digest,    nil,                            '::Digest::SHA256.hexdigest(%s)',  'digest/sha2'   ],
-      sha384:   [ :digest,    nil,                            '::Digest::SHA384.hexdigest(%s)',  'digest/sha2'   ],
-      sha512:   [ :digest,    nil,                            '::Digest::SHA512.hexdigest(%s)',  'digest/sha2'   ],
-      city32:   [ :digest,    nil,                            '::CityHash.hash32(%s).to_s(16)',  'cityhash'      ],
-      city64:   [ :digest,    nil,                            '::CityHash.hash64(%s).to_s(16)',  'cityhash'      ],
-      city128:  [ :digest,    nil,                            '::CityHash.hash128(%s).to_s(16)', 'cityhash'      ],
-      prefix:   [ :prefix,    nil,                            '(options[:prefix] || @prefix)+%s'                 ],
-      spread:   [ :spread,    nil,                            'Helper.spread(%s)'                                ],
-      to_s:     [ :string,    nil,                            '%s.to_s'                                          ],
-      inspect:  [ :string,    nil,                            '%s.inspect'                                       ]
+      escape:   [ :encode,    'Helper.unescape(%s)',          'Helper.escape(%s)'                               ],
+      hex:      [ :encode,    "[%s].pack('H*')",              "%s.unpack('H*').first"                           ],
+      qp:       [ :encode,    "%s.unpack('M').first",         "[%s].pack('M')"                                  ],
+      uuencode: [ :encode,    "%s.unpack('u').first",         "[%s].pack('u')"                                  ],
+      hmac:     [
+        :hmac,
+        'Helper.hmacverify(%s, options[:secret] || @secret)',
+        'Helper.hmacsign(%s, options[:secret] || @secret)',
+        'openssl'
+      ],
+      prefix:   [
+        :prefix,
+        "%s.sub(@prefix, '')",
+        '(options[:prefix] || @prefix)+%s',
+        nil,
+        "%s.start_with?(@prefix)"
+      ],
+      truncate: [ :truncate,  nil,                            'Helper.truncate(%s, @maxlen)',    'digest/md5'   ],
+      md5:      [ :digest,    nil,                            '::Digest::MD5.hexdigest(%s)',     'digest/md5'   ],
+      rmd160:   [ :digest,    nil,                            '::Digest::RMD160.hexdigest(%s)',  'digest/rmd160'],
+      sha1:     [ :digest,    nil,                            '::Digest::SHA1.hexdigest(%s)',    'digest/sha1'  ],
+      sha256:   [ :digest,    nil,                            '::Digest::SHA256.hexdigest(%s)',  'digest/sha2'  ],
+      sha384:   [ :digest,    nil,                            '::Digest::SHA384.hexdigest(%s)',  'digest/sha2'  ],
+      sha512:   [ :digest,    nil,                            '::Digest::SHA512.hexdigest(%s)',  'digest/sha2'  ],
+      city32:   [ :digest,    nil,                            '::CityHash.hash32(%s).to_s(16)',  'cityhash'     ],
+      city64:   [ :digest,    nil,                            '::CityHash.hash64(%s).to_s(16)',  'cityhash'     ],
+      city128:  [ :digest,    nil,                            '::CityHash.hash128(%s).to_s(16)', 'cityhash'     ],
+      spread:   [ :spread,    nil,                            'Helper.spread(%s)'                               ],
+      to_s:     [ :string,    nil,                            '%s.to_s'                                         ],
+      inspect:  [ :string,    nil,                            '%s.inspect'                                      ]
     }.freeze
 
     # Allowed value transformers (Read it like a regular expression!)
@@ -51,5 +64,11 @@ module Moneta
 
     # Allowed key transformers (Read it like a regular expression!)
     KEY_TRANSFORMER = '(serialize | string)? prefix? ((encode? truncate?) | (digest spread?))?'.freeze
+
+    # Key transformers that can be "loaded" (e.g. reversed) and can be used by the key enumeration feature
+    LOAD_KEY_TRANSFORMER = 'serialize? prefix? encode?'.freeze
+
+    # Key transformers that can be "tested for success" with a dumped key and can be used by the key enumeration feature
+    TEST_KEY_TRANSFORMER = 'serialize? prefix? encode?'.freeze
   end
 end

data/lib/moneta/version.rb

@@ -1,5 +1,5 @@
 module Moneta
   # Moneta version number
   # @api public
-  VERSION = '1.2.1'.freeze
+  VERSION = '1.3.0'.freeze
 end

data/moneta.gemspec

@@ -25,7 +25,7 @@ Gem::Specification.new do |s|
     'source_code_uri'   => "https://github.com/moneta-rb/moneta/tree/v#{s.version}",
   }
 
-  s.required_ruby_version = '>= 2.2.2'
+  s.required_ruby_version = '>= 2.3.0'
 
   s.add_development_dependency 'rspec', '~> 3.0'
   s.add_development_dependency 'rspec-retry', '~> 0.6.1'
@@ -33,5 +33,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'parallel_tests', '~> 2.29.2'
   s.add_development_dependency 'timecop', '~> 0.9.1'
   s.add_development_dependency 'rubocop', '~> 0.67.2'
-  s.add_development_dependency 'irb', '~> 1.0.0'
+  s.add_development_dependency 'irb', '1.2.1'
 end

data/script/benchmarks

@@ -36,6 +36,9 @@ class MonetaBenchmarks
   postgres_database1 = ENV['MONETA_POSTGRES_DATABSASE1'] || 'moneta1'
   postgres_database2 = ENV['MONETA_POSTGRES_DATABSASE1'] || 'moneta2'
 
+  couch_login = ENV['COUCH_LOGIN'] || 'admin'
+  couch_password = ENV['COUCH_PASSWORD'] || 'password'
+
   STORES = [
     # SDBM accepts only very short key/value pairs (1k for both)
     {name: "SDBM", sizes: [:small], options: {file: "#{DIR}/sdbm"}},
@@ -112,7 +115,9 @@ class MonetaBenchmarks
         backend: if defined?(JRUBY_VERSION)
                    require 'faraday/adapter/manticore'
                    ::Faraday.new("http://127.0.0.1:5984/moneta") { |f| f.adapter :manticore }
-                 end
+                 end,
+        login: couch_login,
+        password: couch_password
       },
       clear_options: { compact: true, await_compact: true },
     },

data/script/contributors

@@ -2,7 +2,6 @@
 git log --format='%aN <%aE>' |\
 sed -e 's/hiddenbek/Scott Wadden/g' |\
 sed -e 's/Asmod4n/Hendrik Beskow/' |\
-sed -e 's/asppsa@gmail.com/me@asph.dev/' |\
-grep -v 'hannes.georg@xing.com\|spotapov\|yehuda-katzs-mac\|wycats ' |\
+grep -v 'asppsa@gmail.com\|hannes.georg@xing.com\|spotapov\|yehuda-katzs-mac\|wycats ' |\
 sort -u | sort > CONTRIBUTORS
 

data/script/start-couchdb

@@ -0,0 +1,27 @@
+#!/bin/bash
+set -e
+
+# Copied from https://github.com/apache/couchdb-pkg/blob/master/debian/README.Debian
+COUCHDB_PASSWORD=password
+echo "couchdb couchdb/mode select standalone
+couchdb couchdb/mode seen true
+couchdb couchdb/bindaddress string 127.0.0.1
+couchdb couchdb/bindaddress seen true
+couchdb couchdb/adminpass password ${COUCHDB_PASSWORD}
+couchdb couchdb/adminpass seen true
+couchdb couchdb/adminpass_again password ${COUCHDB_PASSWORD}
+couchdb couchdb/adminpass_again seen true" | sudo debconf-set-selections
+DEBIAN_FRONTEND=noninteractive sudo apt-get install -y --force-yes couchdb
+
+# Reconfigure CouchDB to use delayed commits for speed: http://guide.couchdb.org/draft/performance.html
+sudo sed -i '/\[couchdb\]/a delayed_commits = true' /etc/couchdb/local.ini
+
+# (Re)start couchdb
+sudo systemctl restart couchdb
+
+# Display some info about CouchDB
+sudo systemctl status couchdb
+until curl http://localhost:5984/; do
+  sleep 1
+done
+

data/script/start-hbase

@@ -8,13 +8,13 @@ mkdir -p zookeeper
 mkdir -p downloads
 root=$(pwd)
 
-version=$(curl -sS https://www-us.apache.org/dist/hbase/stable/ | grep -oP '(?<=hbase-)(\d+\.?)+' | head -n1)
+version=$(curl -sS https://downloads.apache.org/hbase/stable/RELEASENOTES.md | grep -oP '(?<=# HBASE\s\s)(\d+\.?)+' | head -n1)
 
 echo HBase stable version is $version
 
 if [ ! -f downloads/hbase-$version-bin.tar.gz ]; then
   echo Downloading HBase ...
-  wget -P downloads http://www-us.apache.org/dist/hbase/stable/hbase-$version-bin.tar.gz
+  wget -P downloads https://downloads.apache.org/hbase/stable/hbase-$version-bin.tar.gz
 fi
 
 echo Extracting HBase ...

data/script/start-services

@@ -1,9 +1,9 @@
 #!/bin/bash
 
-# Restart CouchDB
-$(dirname $0)/reconfigure-couchdb
+# Install and start CouchDB
+$(dirname $0)/start-couchdb
 
-# Start HBase
+# Install and start HBase
 $(dirname $0)/start-hbase
 
 # Waiting for servers to start

data/spec/features/store.rb

@@ -178,7 +178,7 @@ shared_examples :store do
   shared_examples :merge! do
     it 'stores values' do
       moneta_property_of(keys: 3, values: 3).check do |keys:, values:|
-        expect(store.public_send(method, pairs.call(keys[0] => values[0], keys[1] => values[1], keys[2] => values[2]))).to be store
+        expect(store.public_send(method, pairs.call({ keys[0] => values[0], keys[1] => values[1], keys[2] => values[2] }))).to be store
         expect(store.key?(keys[0])).to be true
         expect(store[keys[0]]).to eq values[0]
         expect(store.key?(keys[1])).to be true
@@ -192,7 +192,7 @@ shared_examples :store do
     it 'overwrites existing values' do
       moneta_property_of(keys: 2, values: 3).check do |keys:, values:|
         expect(store[keys[0]] = values[0]).to eq values[0]
-        expect(store.public_send(method, pairs.call(keys[0] => values[1], keys[1] => values[2]))).to be store
+        expect(store.public_send(method, pairs.call({ keys[0] => values[1], keys[1] => values[2] }))).to be store
         expect(store.key?(keys[0])).to be true
         expect(store[keys[0]]).to eq values[1]
         expect(store.key?(keys[1])).to be true
@@ -204,7 +204,7 @@ shared_examples :store do
     it 'stores the return value of the block, if given, for keys that will be overwritten' do
       moneta_property_of(keys: 2, values: 4).check do |keys:, values:|
         expect(store[keys[0]] = values[0]).to eq values[0]
-        expect(store.public_send(method, pairs.call(keys[0] => values[1], keys[1] => values[2])) do |key, old_val, new_val|
+        expect(store.public_send(method, pairs.call({ keys[0] => values[1], keys[1] => values[2] })) do |key, old_val, new_val|
           expect(key).to eq keys[0]
           expect(old_val).to eq values[0]
           expect(new_val).to eq values[1]

data/spec/features/transform_value.rb

@@ -1,26 +1,11 @@
 shared_examples :transform_value do
-  describe 'with the :raw option' do
-    it 'can load without transforming the value' do
-      moneta_property_of(values: 1).check do |values:|
-        store['key'] = values[0]
-        load_value(store.load('key', raw: true)).should == values[0]
-      end
-    end
-
-    it 'can store without transforming the value' do
-      moneta_property_of(values: 1).check do |values:|
-        store['key'] = values[0]
-        store.store('key', store.load('key', raw: true), raw: true)
-        store.load('key').should == values[0]
-      end
-    end
+  it 'allows to bypass transformer with :raw' do
+    store['key'] = 'value'
+    load_value(store.load('key', raw: true)).should == 'value'
 
-    it 'can delete without transforming the value' do
-      moneta_property_of(values: 1).check do |values:|
-        store['key'] = values[0]
-        load_value(store.delete('key', raw: true)).should == values[0]
-      end
-    end
+    store.store('key', 'value', raw: true)
+    store.load('key', raw: true).should == 'value'
+    store.delete('key', raw: true).should == 'value'
   end
 
   it 'allows to bypass transformer with raw syntactic sugar' do
@@ -35,4 +20,25 @@ shared_examples :transform_value do
     store.raw['key'] = 'value2'
     store.raw['key'].should == 'value2'
   end
+
+  it 'returns unmarshalled value' do
+    store.store('key', 'unmarshalled value', raw: true)
+    store.load('key', raw: true).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
 end