moneta 1.1.1 → 1.2.0

data/lib/moneta/proxy.rb

@@ -128,8 +128,8 @@ module Moneta
       end
 
       # (see Defaults::ClassMethods#not_supports)
-      def not_supports *features
-        @features_mask = (self.features_mask | features).freeze
+      def not_supports(*features)
+        @features_mask = (features_mask | features).freeze
         super
       end
     end

data/lib/moneta/server.rb

@@ -30,12 +30,10 @@ module Moneta
       @stop = false
       @running = true
       begin
-        until @stop
-          mainloop
-        end
+        mainloop until @stop
       ensure
         File.unlink(@socket) if @socket
-        @ios.each{ |io| io.close rescue nil }
+        @ios.each { |io| io.close rescue nil }
       end
     end
 
@@ -74,7 +72,7 @@ module Moneta
     rescue SignalException => ex
       warn "Moneta::Server - #{ex.message}"
       raise if ex.signo == 15 || ex.signo == 2 # SIGTERM or SIGINT
-    rescue Exception => ex
+    rescue => ex
       warn "Moneta::Server - #{ex.message}"
     end
 
@@ -83,15 +81,14 @@ module Moneta
       @clients.delete(io)
     end
 
-    def pack(o)
-      s = Marshal.dump(o)
+    def pack(obj)
+      s = Marshal.dump(obj)
       [s.bytesize].pack('N') << s
     end
 
     def handle(io, buffer)
-      buffer = @clients[io]
       return if buffer.bytesize < 8 # At least 4 bytes for the marshalled array
-      size = buffer[0,4].unpack('N').first
+      size = buffer[0, 4].unpack('N').first
       if size > MAXSIZE
         delete_client(io)
         return
@@ -101,7 +98,7 @@ module Moneta
       method, *args = Marshal.load(buffer.slice!(0, size))
       case method
       when :key?, :load, :delete, :increment, :create
-        io.write(pack @store.send(method, *args))
+        io.write(pack(@store.send(method, *args)))
       when :features
         # all features except each_key are supported
         io.write(pack(@store.features - [:each_key]))
@@ -114,9 +111,9 @@ module Moneta
     rescue IOError => ex
       warn "Moneta::Server - #{ex.message}" unless ex.message =~ /closed/
       delete_client(io)
-    rescue Exception => ex
+    rescue => ex
       warn "Moneta::Server - #{ex.message}"
-      io.write(pack Exception.new(ex.message))
+      io.write(pack(Exception.new(ex.message)))
     end
 
     def start(options)

data/lib/moneta/shared.rb

@@ -42,7 +42,7 @@ module Moneta
       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

data/lib/moneta/stack.rb

@@ -42,7 +42,7 @@ module Moneta
 
     # (see Proxy#key?)
     def key?(key, options = {})
-      @stack.any? {|s| s.key?(key, options) }
+      @stack.any? { |s| s.key?(key, options) }
     end
 
     # (see Proxy#load)
@@ -56,21 +56,21 @@ module Moneta
 
     # (see Proxy#store)
     def store(key, value, options = {})
-      @stack.each {|s| s.store(key, value, options) }
+      @stack.each { |s| s.store(key, value, options) }
       value
     end
 
     # (see Proxy#increment)
     def increment(key, amount = 1, options = {})
       last = nil
-      @stack.each {|s| last = s.increment(key, amount, options) }
+      @stack.each { |s| last = s.increment(key, amount, options) }
       last
     end
 
     # (see Proxy#create)
     def create(key, value, options = {})
       last = false
-      @stack.each {|s| last = s.create(key, value, options) }
+      @stack.each { |s| last = s.create(key, value, options) }
       last
     end
 
@@ -84,13 +84,13 @@ module Moneta
 
     # (see Proxy#clear)
     def clear(options = {})
-      @stack.each {|s| s.clear(options) }
+      @stack.each { |s| s.clear(options) }
       self
     end
 
     # (see Proxy#close)
     def close
-      @stack.each {|s| s.close }
+      @stack.each { |s| s.close }
       nil
     end
 

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
@@ -49,13 +49,13 @@ module Moneta
         raise ArgumentError, 'Invalid value transformer chain' if @value_validator !~ values.map(&:inspect).join
 
         klass = Class.new(self)
-        klass.class_eval <<-end_eval, __FILE__, __LINE__
+        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')
         dump, dump_opts = compile_transformer(values, 'value')
@@ -78,7 +78,7 @@ module Moneta
       end
 
       def compile_key_transformer(klass, key, key_opts)
-        klass.class_eval <<-end_eval, __FILE__, __LINE__
+        klass.class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
           not_supports :each_key
 
           def key?(key, options = {})
@@ -129,11 +129,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,11 +197,11 @@ 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__
+        klass.class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
           not_supports :each_key
 
           def key?(key, options = {})
@@ -292,7 +292,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,19 +305,21 @@ 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]
           options += code.scan(/options\[:(\w+)\]/).flatten
           value =
             if t[0] == :serialize && var == 'key'
@@ -326,11 +328,11 @@ module Moneta
               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

data/lib/moneta/transformer/config.rb

@@ -22,7 +22,8 @@ module Moneta
       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')"                                   ],
@@ -42,13 +43,13 @@ module Moneta
       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'                                       ],
-    }
+      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
   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_-]+/) { '%' + $&.unpack('H2' * $&.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})+)/) { |matches| [matches[1].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,26 @@
 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
-          ::BSON::Document.from_bson(::BSON::ByteBuffer.new(value))['v']
-        end
+        if ::BSON::VERSION >= '4.0.0'
+          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.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
+          end
         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.2.0'.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

@@ -14,18 +14,21 @@ 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)
-          end
+                  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)
+                  end
         new(cache)
       end
     end
@@ -82,7 +85,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