moneta 1.1.1 → 1.4.1

data/lib/moneta/synchronize.rb

@@ -21,7 +21,7 @@ module Moneta
       raise 'Already locked' if @locked
       enter_primitive ? @locked = true : false
     end
-    alias_method :try_lock, :try_enter
+    alias try_lock try_enter
 
     # Enter critical section (blocking)
     #
@@ -36,7 +36,7 @@ module Moneta
       end
       false
     end
-    alias_method :lock, :enter
+    alias lock enter
 
     # Leave critical section
     def leave
@@ -45,7 +45,7 @@ module Moneta
       @locked = false
       nil
     end
-    alias_method :unlock, :leave
+    alias unlock leave
 
     # Is the lock acquired?
     def locked?

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,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)
-        klass.class_eval <<-end_eval, __FILE__, __LINE__
-          not_supports :each_key
+      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
@@ -129,11 +149,11 @@ module Moneta
             @adapter.merge!(t_keys.zip(values), #{without :raw, key_opts}, &block)
             self
           end
-        end_eval
+        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
@@ -197,16 +217,25 @@ module Moneta
             @adapter.merge!(t_pairs, #{without :raw, dump_opts}, &block)
             self
           end
-        end_eval
+        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__
-          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
@@ -292,7 +321,7 @@ module Moneta
             @adapter.merge!(t_pairs, #{without :raw, key_opts, dump_opts}, &block)
             self
           end
-        end_eval
+        END_EVAL
       end
 
       # Compile option initializer
@@ -305,35 +334,50 @@ 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)
-        camel_case = lambda{ |sym| sym.to_s.split('_').map(&:capitalize).join }
+        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
 end

data/lib/moneta/transformer/config.rb

@@ -2,53 +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')"                                  ],
+      # 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'       ],
-      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'                                       ],
-    }
+        :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.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

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/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.1.1'
+  VERSION = '1.4.1'.freeze
 end

data/lib/moneta/weak_each_key.rb

@@ -31,6 +31,8 @@ module Moneta
 
     protected
 
+    attr_reader :all_keys
+
     def wrap(name, *args)
       case name
       when :create, :store, :increment, :create
@@ -63,10 +65,6 @@ module Moneta
       end
     end
 
-    def all_keys
-      @all_keys
-    end
-
     def each_key_save(key)
       @all_keys = Set.new(@all_keys).add(key)
     end

data/lib/rack/cache/moneta.rb

@@ -15,16 +15,18 @@ module Rack
       def resolve(uri)
         cache = Rack::Cache::Moneta[uri.to_s.sub(%r{^moneta://}, '')] ||=
           begin
-            options = parse_query(uri.query)
-            options.keys.each do |key|
-            options[key.to_sym] =
-              case value = options.delete(key)
-              when 'true'; true
-              when 'false'; false
-              else value
-              end
-          end
-            ::Moneta.new(uri.host.to_sym, options)
+            options = parse_query(uri.query).map do |key, value|
+              [key.to_sym,
+               case value
+               when 'true'
+                 true
+               when 'false'
+                 false
+               else
+                 value
+               end]
+            end
+            ::Moneta.new(uri.host.to_sym, options.to_h)
           end
         new(cache)
       end
@@ -82,7 +84,7 @@ module Rack
         def write(body, ttl = 0)
           buf = StringIO.new
           key, size = slurp(body) { |part| buf.write(part) }
-          @cache.store(key, buf.string, ttl == 0 ? {} : {expires: ttl})
+          @cache.store(key, buf.string, ttl == 0 ? {} : { expires: ttl })
           [key, size]
         end