moneta 1.0.0 → 1.5.1

data/lib/moneta/transformer/config.rb

@@ -2,51 +2,73 @@ 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')"                                  ],
-      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'                                       ],
-    }
+      # 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'
+      ],
+      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!)
-    VALUE_TRANSFORMER = 'serialize? compress? hmac? encode?'
+    VALUE_TRANSFORMER = 'serialize? compress? hmac? encode?'.freeze
 
     # Allowed key transformers (Read it like a regular expression!)
-    KEY_TRANSFORMER = '(serialize | string)? prefix? ((encode? truncate?) | (digest spread?))?'
+    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/transformer/helper/bson.rb

@@ -1,23 +1,16 @@
 module Moneta
   class Transformer
-    module Helper::BSON
-      extend self
+    module Helper
+      # @api private
+      module BSON
+        extend self
 
-      if ::BSON::VERSION >= '4.0.0'
-        def load value
+        def load(value)
           ::BSON::Document.from_bson(::BSON::ByteBuffer.new(value))['v']
         end
 
-        def dump value
-          ::BSON::Document['v'=>value].to_bson.to_s
-        end
-      else
-        def load value
-          ::BSON::Document.from_bson(::StringIO.new(value))['v']
-        end
-
-        def dump value
-          ::BSON::Document['v'=>value].to_bson
+        def dump(value)
+          ::BSON::Document['v' => value].to_bson.to_s
         end
       end
     end

data/lib/moneta/transformer/helper.rb

@@ -5,11 +5,11 @@ module Moneta
       extend self
 
       def escape(value)
-        value.gsub(/[^a-zA-Z0-9_-]+/){ '%' + $&.unpack('H2' * $&.bytesize).join('%').upcase }
+        value.gsub(/[^a-zA-Z0-9_-]+/) { |match| '%' + match.unpack('H2' * match.bytesize).join('%').upcase }
       end
 
       def unescape(value)
-        value.gsub(/((?:%[0-9a-fA-F]{2})+)/){ [$1.delete('%')].pack('H*') }
+        value.gsub(/(?:%[0-9a-fA-F]{2})+/) { |match| [match.delete('%')].pack('H*') }
       end
 
       def hmacverify(value, secret)
@@ -24,7 +24,7 @@ module Moneta
       def truncate(value, maxlen)
         if value.size >= maxlen
           digest = Digest::MD5.hexdigest(value)
-          value = value[0, maxlen-digest.size] << digest
+          value = value[0, maxlen - digest.size] << digest
         end
         value
       end
@@ -35,14 +35,14 @@ module Moneta
 
       def bzip2(value)
         io = ::StringIO.new
-        bz = ::RBzip2::Compressor.new(io)
+        bz = ::RBzip2.default_adapter::Compressor.new(io)
         bz.write(value)
         bz.close
         io.string
       end
 
       def bunzip2(value)
-        ::RBzip2::Decompressor.new(::StringIO.new(value)).read
+        ::RBzip2.default_adapter::Decompressor.new(::StringIO.new(value)).read
       end
 
       autoload :BSON, 'moneta/transformer/helper/bson'

data/lib/moneta/transformer.rb

@@ -19,7 +19,7 @@ module Moneta
   # @api public
   class Transformer < Proxy
     class << self
-      alias_method :original_new, :new
+      alias original_new new
 
       # @param [Moneta store] adapter The underlying store
       # @param [Hash] options
@@ -43,30 +43,35 @@ 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)
-        klass.class_eval <<-end_eval, __FILE__, __LINE__
+        compile_each_key_support_clause(klass, keys)
+        klass.class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
           def initialize(adapter, options = {})
             super
             #{compile_initializer('key', keys)}
             #{compile_initializer('value', values)}
           end
-        end_eval
+        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,11 +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)
-        klass.class_eval <<-end_eval, __FILE__, __LINE__
+      def compile_each_key_support_clause(klass, keys)
+        klass.class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
+          #{'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
@@ -97,11 +119,41 @@ module Moneta
           def create(key, value, options = {})
             @adapter.create(#{key}, value, #{without :raw, key_opts})
           end
-        end_eval
+          def values_at(*keys, **options)
+            t_keys = keys.map { |key| #{key} }
+            @adapter.values_at(*t_keys, **#{without :raw, key_opts})
+          end
+          def fetch_values(*keys, **options)
+            t_keys = keys.map { |key| #{key} }
+
+            block = if block_given?
+                      key_lookup = Hash[t_keys.zip(keys)]
+                      lambda { |t_key| yield key_lookup[t_key] }
+                    end
+            @adapter.fetch_values(*t_keys, **#{without :raw, key_opts}, &block)
+          end
+          def slice(*keys, **options)
+            t_keys = keys.map { |key| #{key} }
+            key_lookup = Hash[t_keys.zip(keys)]
+            @adapter.slice(*t_keys, **#{without :raw, key_opts}).map do |key, value|
+              [key_lookup[key], value]
+            end
+          end
+          def merge!(pairs, options = {})
+            keys, values = pairs.to_a.transpose
+            t_keys = keys.map { |key| #{key} }
+            block = if block_given?
+                      key_lookup = Hash[t_keys.zip(keys)]
+                      lambda { |k, old, new| yield(key_lookup[k], old, new) }
+                    end
+            @adapter.merge!(t_keys.zip(values), #{without :raw, key_opts}, &block)
+            self
+          end
+        END_EVAL
       end
 
       def compile_value_transformer(klass, load, load_opts, dump, dump_opts)
-        klass.class_eval <<-end_eval, __FILE__, __LINE__
+        klass.class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
           def load(key, options = {})
             value = @adapter.load(key, #{without :raw, load_opts})
             value && !options[:raw] ? #{load} : value
@@ -117,14 +169,73 @@ module Moneta
           def create(key, value, options = {})
             @adapter.create(key, options[:raw] ? value : #{dump}, #{without :raw, dump_opts})
           end
-        end_eval
+          def values_at(*keys, **options)
+            values = @adapter.values_at(*keys, **#{without :raw, load_opts})
+            values.map do |value|
+              value && !options[:raw] ? #{load} : value
+            end
+          end
+          def fetch_values(*keys, **options, &orig_block)
+            substituted = {}
+            block = if block_given?
+                      lambda { |key| substituted[key] = true; yield key }
+                    end
+
+            values = @adapter.fetch_values(*keys, **#{without :raw, load_opts}, &block)
+            if options[:raw]
+              values
+            else
+              keys.map(&substituted.method(:key?)).zip(values).map do |substituted, value|
+                if substituted || !value
+                  value
+                else
+                  #{load}
+                end
+              end
+            end
+          end
+          def slice(*keys, **options)
+            @adapter.slice(*keys, **#{without :raw, load_opts}).map do |key, value|
+              [key, value && !options[:raw] ? #{load} : value]
+            end
+          end
+          def merge!(pairs, options = {}, &orig_block)
+            block = if block_given?
+                      if options[:raw]
+                        orig_block
+                      else
+                        lambda do |k, old_val, new_val|
+                          value = old_val; old_val = #{load}
+                          value = new_val; new_val = #{load}
+                          value = yield(k, old_val, new_val)
+                          #{dump}
+                        end
+                      end
+                    end
+
+            t_pairs = options[:raw] ? pairs : pairs.map { |key, value| [key, #{dump}] }
+            @adapter.merge!(t_pairs, #{without :raw, dump_opts}, &block)
+            self
+          end
+        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__
+      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
@@ -143,7 +254,74 @@ module Moneta
           def create(key, value, options = {})
             @adapter.create(#{key}, options[:raw] ? value : #{dump}, #{without :raw, key_opts, dump_opts})
           end
-        end_eval
+          def values_at(*keys, **options)
+            t_keys = keys.map { |key| #{key} }
+            values = @adapter.values_at(*t_keys, **#{without :raw, key_opts, load_opts})
+            values.map do |value|
+              value && !options[:raw] ? #{load} : value
+            end
+          end
+          def fetch_values(*keys, **options)
+            t_keys = keys.map { |key| #{key} }
+            key_lookup = Hash[t_keys.zip(keys)]
+            substituted = {}
+            block = if block_given?
+                      lambda do |t_key|
+                        key = key_lookup[t_key]
+                        substituted[key] = true
+                        yield key
+                      end
+                    end
+
+            values = @adapter.fetch_values(*t_keys, **#{without :raw, key_opts, load_opts}, &block)
+
+            if options[:raw]
+              values
+            else
+              keys.map(&substituted.method(:key?)).zip(values).map do |substituted, value|
+                if substituted || !value
+                  value
+                else
+                  #{load}
+                end
+              end
+            end
+          end
+          def slice(*keys, **options)
+            t_keys = keys.map { |key| #{key} }
+            key_lookup = Hash[t_keys.zip(keys)]
+            @adapter.slice(*t_keys, **#{without :raw, key_opts, load_opts}).map do |key, value|
+              [key_lookup[key], value && !options[:raw] ? #{load} : value]
+            end
+          end
+          def merge!(pairs, options = {})
+            keys, values = pairs.to_a.transpose
+            t_keys = keys.map { |key| #{key} }
+            key_lookup = Hash[t_keys.zip(keys)]
+
+            block = if block_given?
+                      if options[:raw]
+                        lambda do |k, old_val, new_val|
+                          yield(key_lookup[k], old_val, new_val)
+                        end
+                      else
+                        lambda do |k, old_val, new_val|
+                          value = old_val; old_val = #{load}
+                          value = new_val; new_val = #{load}
+                          value = yield(key_lookup[k], old_val, new_val)
+                          #{dump}
+                        end
+                      end
+                    end
+            t_pairs = if options[:raw]
+                        t_keys.zip(values)
+                      else
+                        t_keys.zip(values.map { |value| #{dump} })
+                      end
+            @adapter.merge!(t_pairs, #{without :raw, key_opts, dump_opts}, &block)
+            self
+          end
+        END_EVAL
       end
 
       # Compile option initializer
@@ -156,33 +334,49 @@ module Moneta
         end.join("\n")
       end
 
-      def compile_validator(s)
-        Regexp.new('\A' + s.gsub(/\w+/) do
-                     '(' + TRANSFORMER.select {|k,v| v.first.to_s == $& }.map {|v| ":#{v.first}" }.join('|') + ')'
-                   end.gsub(/\s+/, '') + '\Z')
+      def compile_validator(str)
+        Regexp.new('\A' +
+                   str.gsub(/\w+/) do
+                     '(' + TRANSFORMER.select { |_, v| v.first.to_s == $& }.map { |v| ":#{v.first}" }.join('|') + ')'
+                   end.gsub(/\s+/, '') +
+                   '\Z')
       end
 
       # Returned compiled transformer code string
-      def compile_transformer(transformer, var, i = 2)
+      def compile_transformer(transformer, var, idx = 2)
         value, options = var, []
         transformer.each do |name|
           raise ArgumentError, "Unknown transformer #{name}" unless t = TRANSFORMER[name]
           require t[3] if t[3]
-          code = t[i]
+          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
             end
         end
-        return value, options
+        [value, options]
       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')
+        camel_case = lambda { |sym| sym.to_s.split('_').map(&:capitalize).join }
+        (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

data/lib/moneta/utils.rb

@@ -5,9 +5,9 @@ module Moneta
 
     def without(hash, *keys)
       return hash if hash.empty?
-      if keys.any? {|k| hash.include?(k) }
+      if keys.any? { |k| hash.include?(k) }
         hash = hash.dup
-        keys.each {|k| hash.delete(k) }
+        keys.each { |k| hash.delete(k) }
       end
       hash
     end
@@ -15,14 +15,8 @@ module Moneta
     def only(hash, *keys)
       return hash if hash.empty?
       ret = {}
-      keys.each {|k| ret[k] = hash[k] }
+      keys.each { |k| ret[k] = hash[k] }
       ret
     end
-
-    def to_int(value)
-      intvalue = value.to_i
-      raise "#{value.inspect} is not an integer value" unless value == nil || intvalue.to_s == value.to_s
-      intvalue
-    end
   end
 end

data/lib/moneta/version.rb

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

data/lib/moneta/weak_each_key.rb

@@ -0,0 +1,72 @@
+require 'set'
+
+module Moneta
+  # Adds weak key enumeration support to the underlying store
+  #
+  # @note This class wraps methods that store and retrieve entries in order to
+  #   track which keys are in the store, and uses this list when doing key
+  #   traversal.  This means that {#each_key each_key} will only yield keys
+  #   which have been accessed previously via the present store object.  This
+  #   wrapper is therefore best suited to adapters which are not persistent, and
+  #   which cannot be shared.
+  #
+  # @api public
+  class WeakEachKey < Wrapper
+    supports :each_key
+
+    # @param [Moneta store] adapter The underlying store
+    # @param [Hash] options
+    def initialize(adapter, options = {})
+      raise 'Store already supports feature :each_key' if adapter.supports?(:each_key)
+      @all_keys = Set.new
+      super
+    end
+
+    # (see Proxy#each_key)
+    def each_key
+      return enum_for(:each_key) { all_keys.size } unless block_given?
+      all_keys.each { |key| yield key }
+      self
+    end
+
+    protected
+
+    attr_reader :all_keys
+
+    def wrap(name, *args)
+      case name
+      when :create, :store, :increment, :create
+        each_key_save(args[0])
+        yield
+      when :key?
+        if found = yield
+          each_key_save(args[0])
+        else
+          all_keys.delete(args[0])
+        end
+        found
+      when :load
+        key?(*args)
+        yield
+      when :delete
+        all_keys.delete(args[0])
+        yield
+      when :clear, :close
+        all_keys.clear
+        yield
+      when :values_at, :fetch_values, :slice
+        args[0].each { |key| key?(key) }
+        yield
+      when :merge!
+        args[0].each { |key, _| each_key_save(key) }
+        yield
+      else
+        yield
+      end
+    end
+
+    def each_key_save(key)
+      @all_keys = Set.new(@all_keys).add(key)
+    end
+  end
+end