moneta 1.1.1 → 1.2.0

data/lib/moneta/adapters/datamapper.rb

@@ -11,6 +11,7 @@ module Moneta
 
       supports :create
 
+      # @api private
       class Store
         include ::DataMapper::Resource
         property :k, String, key: true, length: 255

data/lib/moneta/adapters/file.rb

@@ -1,4 +1,5 @@
 require 'fileutils'
+require 'English'
 
 module Moneta
   module Adapters
@@ -35,17 +36,18 @@ module Moneta
       def load(key, options = {})
         ::File.read(store_path(key), mode: 'rb')
       rescue Errno::ENOENT
+        nil
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        temp_file = ::File.join(@dir, "value-#{$$}-#{Thread.current.object_id}")
+        temp_file = ::File.join(@dir, "value-#{$PROCESS_ID}-#{Thread.current.object_id}")
         path = store_path(key)
         FileUtils.mkpath(::File.dirname(path))
-        ::File.open(temp_file, 'wb') {|f| f.write(value) }
+        ::File.open(temp_file, 'wb') { |f| f.write(value) }
         ::File.rename(temp_file, path)
         value
-      rescue Exception
+      rescue
         File.unlink(temp_file) rescue nil
         raise
       end
@@ -56,11 +58,12 @@ module Moneta
         ::File.unlink(store_path(key))
         value
       rescue Errno::ENOENT
+        nil
       end
 
       # (see Proxy#clear)
       def clear(options = {})
-        temp_dir = "#{@dir}-#{$$}-#{Thread.current.object_id}"
+        temp_dir = "#{@dir}-#{$PROCESS_ID}-#{Thread.current.object_id}"
         ::File.rename(@dir, temp_dir)
         FileUtils.mkpath(@dir)
         self
@@ -77,7 +80,7 @@ module Moneta
         ::File.open(path, ::File::RDWR | ::File::CREAT) do |f|
           Thread.pass until f.flock(::File::LOCK_EX)
           content = f.read
-          amount += Utils.to_int(content) unless content.empty?
+          amount += Integer(content) unless content.empty?
           content = amount.to_s
           f.binmode
           f.pos = 0
@@ -96,7 +99,7 @@ module Moneta
           FileUtils.mkpath(::File.dirname(path))
           # Call native java.io.File#createNewFile
           return false unless ::Java::JavaIo::File.new(path).createNewFile
-          ::File.open(path, 'wb+') {|f| f.write(value) }
+          ::File.open(path, 'wb+') { |f| f.write(value) }
           true
         end
       else

data/lib/moneta/adapters/hbase.rb

@@ -53,7 +53,7 @@ module Moneta
       def increment(key, amount = 1, options = {})
         result = @table.atomic_increment(key, @column, amount)
         # HACK: Throw error if applied to invalid value
-        Utils.to_int(load(key)) if result == 0
+        Integer(load(key)) if result == 0
         result
       end
 

data/lib/moneta/adapters/kyotocabinet.rb

@@ -48,19 +48,20 @@ module Moneta
       # (see Proxy#each_key)
       def each_key
         return enum_for(:each_key) { @backend.count } unless block_given?
-        @backend.each_key{ |arr| yield arr[0] }
+        @backend.each_key { |arr| yield arr[0] }
         self
       end
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
         ret = nil
-        success = @backend.accept(key) do |key, value|
-          if value
-            ret = Integer(value) + amount
-          else
-            ret = amount
-          end
+        success = @backend.accept(key) do |_, value|
+          ret =
+            if value
+              Integer(value) + amount
+            else
+              amount
+            end
           ret.to_s
         end
 

data/lib/moneta/adapters/leveldb.rb

@@ -30,7 +30,7 @@ module Moneta
 
       # (see Proxy#clear)
       def clear(options = {})
-        @backend.each {|k,v| delete(k, options) }
+        @backend.each { |k,| delete(k, options) }
         self
       end
 

data/lib/moneta/adapters/lmdb.rb

@@ -11,7 +11,7 @@ module Moneta
       supports :create, :increment, :each_key
       attr_reader :backend, :db
 
-      PUT_FLAGS = [:nooverwrite, :nodupdata, :current, :append, :appenddup]
+      PUT_FLAGS = %i[nooverwrite nodupdata current append appenddup].freeze
 
       # @param [Hash] options
       # @option options [String] :dir Environment directory
@@ -31,7 +31,7 @@ module Moneta
 
       # (see Proxy#key?)
       def key?(key, options = {})
-        !@db.get(key).nil?
+        @db.get(key) != nil
       end
 
       # (see Proxy#load)
@@ -64,8 +64,7 @@ module Moneta
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
         @backend.transaction do
-          value = @db.get(key)
-          value = Utils.to_int(value) + amount
+          value = Integer(@db.get(key) || 0) + amount
           @db.put(key, value.to_s, Utils.only(options, *PUT_FLAGS))
           value
         end

data/lib/moneta/adapters/lruhash.rb

@@ -2,7 +2,8 @@ module Moneta
   module Adapters
     # LRUHash backend
     #
-    # Based on Hashery::LRUHash but simpler and measures both memory usage and hash size.
+    # Based on {https://rubygems.org/gems/lru_redux lru_redux} but measures
+    # both memory usage and hash size.
     #
     # @api public
     class LRUHash
@@ -28,22 +29,24 @@ module Moneta
 
       # (see Proxy#key?)
       def key?(key, options = {})
-        @entry.key?(key)
+        @backend.key?(key)
       end
 
       # (see Proxy#each_key)
       def each_key(&block)
-        return enum_for(:each_key) { @entry.length } unless block_given?
+        return enum_for(:each_key) { @backend.length } unless block_given?
 
-        @entry.each_key { |k| yield(k) }
+        # The backend needs to be duplicated because reading mutates this
+        # store.
+        @backend.dup.each_key { |k| yield(k) }
         self
       end
 
       # (see Proxy#load)
       def load(key, options = {})
-        if entry = @entry[key]
-          entry.insert_after(@list)
-          entry.value
+        if value = @backend.delete(key)
+          @backend[key] = value
+          value
         end
       end
 
@@ -52,76 +55,40 @@ module Moneta
         if @max_value && value.bytesize > @max_value
           delete(key)
         else
-          if entry = @entry[key]
-            @size -= entry.value.bytesize if @max_size
-          else
-            @entry[key] = entry = Entry.new
-            entry.key = key
+          if @max_size
+            if old_value = @backend.delete(key)
+              @size -= old_value.bytesize
+            end
+            @size += value.bytesize
           end
-          entry.value = value
-          @size += entry.value.bytesize if @max_size
-          entry.insert_after(@list)
-          delete(@list.prev.key) while @list.next != @list.prev && (@max_size && @size > @max_size || @max_count && @entry.size > @max_count)
+          @backend[key] = value
+          drop while @max_size && @size > @max_size || @max_count && @backend.size > @max_count
         end
         value
       end
 
       # (see Proxy#delete)
       def delete(key, options = {})
-        if entry = @entry.delete(key)
-          @size -= entry.value.bytesize if @max_size
-          entry.unlink
-          entry.value
+        if value = @backend.delete(key) and @max_size
+          @size -= value.bytesize
         end
+        value
       end
 
       # (see Proxy#clear)
       def clear(options = {})
-        @entry, @size = {}, 0
-        @list = Entry.new
-        @list.prev = @list.next = @list
+        @backend = {}
+        @size = 0
         self
       end
 
-      # (see Proxy#values_at)
-      def values_at(*keys, **options)
-        @entry.values_at(*keys).map do |entry|
-          if entry
-            entry.insert_after(@list)
-            entry.value
-          end
-        end
-      end
-
-      # (see Proxy#slice)
-      def slice(*keys, **options)
-        return super unless @entry.respond_to?(:slice)
-        hash = @entry.slice(*keys)
-        hash.each do |key, entry|
-          entry.insert_after(@list)
-          hash[key] = entry.value
-        end
-      end
-
-      private
-
-      class Entry
-        attr_accessor :key, :value, :prev, :next
-
-        def unlink
-          @prev.next = @next if @prev
-          @next.prev = @prev if @next
-          @prev = @next = nil
-        end
-
-        def insert_after(entry)
-          if entry.next != self
-            unlink
-            @next = entry.next
-            @prev = entry
-            entry.next.prev = self
-            entry.next = self
-          end
+      # Drops the least-recently-used pair, if any
+      #
+      # @param [Hash] options Options to merge
+      # @return [(Object, String), nil] The dropped pair, if any
+      def drop(options = {})
+        if key = @backend.keys.first
+          [key, delete(key)]
         end
       end
     end

data/lib/moneta/adapters/memcached.rb

@@ -1,4 +1,5 @@
 module Moneta
+  # @api private
   module Adapters
     # Prefer Dalli over native Memcached!
     #

data/lib/moneta/adapters/memcached/dalli.rb

@@ -87,7 +87,7 @@ module Moneta
         @backend.get_multi(keys).tap do |pairs|
           next if pairs.empty?
           expires = expires_value(options, nil)
-          next if expires.nil?
+          next if expires == nil
           expires = expires.to_i if Numeric === expires
           expires ||= 0
           @backend.multi do

data/lib/moneta/adapters/memcached/native.rb

@@ -22,7 +22,7 @@ module Moneta
         self.default_expires = options.delete(:expires)
         @backend = options[:backend] ||
           begin
-            options.merge!(prefix_key: options.delete(:namespace)) if options[:namespace]
+            options[:prefix_key] = options.delete(:namespace) if options[:namespace]
             # We don't want a limitation on the key charset. Therefore we use the binary protocol.
             # It is also faster.
             options[:binary_protocol] = true unless options.include?(:binary_protocol)
@@ -35,13 +35,14 @@ module Moneta
         value = @backend.get(key, false)
         if value
           expires = expires_value(options, nil)
-          unless expires.nil?
+          unless expires == nil
             Numeric === expires and expires = expires.to_i
             @backend.set(key, value, expires || 0, false)
           end
           value
         end
       rescue ::Memcached::NotFound
+        nil
       end
 
       # (see Proxy#store)
@@ -59,20 +60,21 @@ module Moneta
         @backend.delete(key)
         value
       rescue ::Memcached::NotFound
+        nil
       end
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
         result = if amount >= 0
-          @backend.increment(key, amount)
-        else
-          @backend.decrement(key, -amount)
-        end
+                   @backend.increment(key, amount)
+                 else
+                   @backend.decrement(key, -amount)
+                 end
         # HACK: Throw error if applied to invalid value
         # see https://github.com/evan/memcached/issues/110
-        Utils.to_int((@backend.get(key, false) rescue nil)) if result == 0
+        Integer((@backend.get(key, false) rescue 0)) if result == 0
         result
-      rescue ::Memcached::NotFound => ex
+      rescue ::Memcached::NotFound
         retry unless create(key, amount.to_s, options)
         amount
       end

data/lib/moneta/adapters/mongo.rb

@@ -1,4 +1,5 @@
 module Moneta
+  # @api private
   module Adapters
     begin
       require 'moneta/adapters/mongo/official'

data/lib/moneta/adapters/mongo/base.rb

@@ -84,9 +84,9 @@ module Moneta
       # BSON will use String#force_encoding to make the string 8-bit
       # ASCII.  This could break unicode text so we should dup in this
       # case, and it also fails with frozen strings.
-      def to_binary(s)
-        s = s.dup if s.frozen? || s.encoding != Encoding::ASCII_8BIT
-        ::BSON::Binary.new(s)
+      def to_binary(str)
+        str = str.dup if str.frozen? || str.encoding != Encoding::ASCII_8BIT
+        ::BSON::Binary.new(str)
       end
 
       if defined?(::BSON::VERSION) and ::BSON::VERSION[0].to_i >= 2

data/lib/moneta/adapters/mongo/moped.rb

@@ -87,11 +87,10 @@ module Moneta
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
         @backend.with(safe: true, consistency: :strong) do |safe|
-          safe[@collection.name].
-            find(_id: to_binary(key)).
-            modify({:$inc => { @value_field => amount }},
-                   new: true,
-                   upsert: true)[@value_field]
+          safe[@collection.name]
+            .find(_id: to_binary(key))
+            .modify({ :$inc => { @value_field => amount } },
+                    new: true, upsert: true)[@value_field]
         end
       rescue ::Moped::Errors::OperationFailure
         tries ||= 0
@@ -120,7 +119,7 @@ module Moneta
 
       # (see Proxy#slice)
       def slice(*keys, **options)
-        query = @collection.find(_id: {:$in => keys.map(&method(:to_binary))})
+        query = @collection.find(_id: { :$in => keys.map(&method(:to_binary)) })
         pairs = query.map do |doc|
           next if doc[@expires_field] && doc[@expires_field] < Time.now
           [from_binary(doc[:_id]), doc_to_value(doc)]
@@ -137,10 +136,10 @@ module Moneta
       def merge!(pairs, options = {})
         @backend.with(safe: true, consistency: :strong) do |safe|
           collection = safe[@collection.name]
-          existing = collection.
-            find(_id: {:$in => pairs.map { |key, _| to_binary(key) }.to_a}).
-            map{ |doc| [from_binary(doc[:_id]), doc_to_value(doc)] }.
-            to_h
+          existing = collection
+            .find(_id: { :$in => pairs.map { |key, _| to_binary(key) }.to_a })
+            .map { |doc| [from_binary(doc[:_id]), doc_to_value(doc)] }
+            .to_h
 
           update_pairs, insert_pairs = pairs.partition { |key, _| existing.key?(key) }
           unless insert_pairs.empty?
@@ -152,9 +151,9 @@ module Moneta
           update_pairs.each do |key, value|
             value = yield(key, existing[key], value) if block_given?
             binary = to_binary(key)
-            collection.
-              find(_id: binary).
-              update(value_to_doc(binary, value, options))
+            collection
+              .find(_id: binary)
+              .update(value_to_doc(binary, value, options))
           end
         end
         self

data/lib/moneta/adapters/mongo/official.rb

@@ -45,7 +45,7 @@ module Moneta
         @backend.use(db)
         @collection = @backend[collection]
         if @backend.command(buildinfo: 1).documents.first['version'] >= '2.2'
-          @collection.indexes.create_one({@expires_field => 1}, expire_after: 0)
+          @collection.indexes.create_one({ @expires_field => 1 }, expire_after: 0)
         else
           warn 'Moneta::Adapters::Mongo - You are using MongoDB version < 2.2, expired documents will not be deleted'
         end
@@ -59,7 +59,7 @@ module Moneta
           expires = expires_at(options, nil)
           # @expires_field must be a Time object (BSON date datatype)
           @collection.update_one({ _id: key },
-                                 '$set' => { @expires_field => expires }) unless expires.nil?
+                                 '$set' => { @expires_field => expires }) unless expires == nil
           doc_to_value(doc)
         end
       end
@@ -84,8 +84,7 @@ module Moneta
       def delete(key, options = {})
         key = to_binary(key)
         if doc = @collection.find(_id: key).find_one_and_delete and
-          !doc[@expires_field] || doc[@expires_field] >= Time.now
-        then
+            !doc[@expires_field] || doc[@expires_field] >= Time.now
           doc_to_value(doc)
         end
       end
@@ -94,8 +93,8 @@ module Moneta
       def increment(key, amount = 1, options = {})
         @collection.find_one_and_update({ _id: to_binary(key) },
                                         { '$inc' => { @value_field => amount } },
-                                        :return_document => :after,
-                                        :upsert => true)[@value_field]
+                                        return_document: :after,
+                                        upsert: true)[@value_field]
       end
 
       # (see Proxy#create)
@@ -122,7 +121,7 @@ module Moneta
 
       # (see Proxy#slice)
       def slice(*keys, **options)
-        query = @collection.find(_id: {:$in => keys.map(&method(:to_binary))})
+        query = @collection.find(_id: { :$in => keys.map(&method(:to_binary)) })
         pairs = query.map do |doc|
           next if doc[@expires_field] && doc[@expires_field] < Time.now
           [from_binary(doc[:_id]), doc_to_value(doc)]
@@ -147,7 +146,7 @@ module Moneta
         update_pairs.each do |key, value|
           value = yield(key, existing[key], value) if block_given?
           binary = to_binary(key)
-          @collection.replace_one({_id: binary}, value_to_doc(binary, value, options))
+          @collection.replace_one({ _id: binary }, value_to_doc(binary, value, options))
         end
 
         self