moneta 1.1.1 → 1.4.1

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,11 +1,269 @@
+require 'mongo'
+
 module Moneta
   module Adapters
-    begin
-      require 'moneta/adapters/mongo/official'
-      Mongo = MongoOfficial
-    rescue LoadError
-      require 'moneta/adapters/mongo/moped'
-      Mongo = MongoMoped
+    # MongoDB backend
+    #
+    # Supports expiration, documents will be automatically removed starting
+    # with mongodb >= 2.2 (see {http://docs.mongodb.org/manual/tutorial/expire-data/}).
+    #
+    # You can store hashes directly using this adapter.
+    #
+    # @example Store hashes
+    #     db = Moneta::Adapters::MongoOfficial.new
+    #     db['key'] = {a: 1, b: 2}
+    #
+    # @api public
+    class Mongo
+      include Defaults
+      include ExpiresSupport
+
+      supports :each_key, :create, :increment
+      attr_reader :backend
+
+      DEFAULT_PORT = 27017
+
+      # @param [Hash] options
+      # @option options [String] :collection ('moneta') MongoDB collection name
+      # @option options [String] :host ('127.0.0.1') MongoDB server host
+      # @option options [String] :user Username used to authenticate
+      # @option options [String] :password Password used to authenticate
+      # @option options [Integer] :port (MongoDB default port) MongoDB server port
+      # @option options [String] :database ('moneta') MongoDB database
+      # @option options [Integer] :expires Default expiration time
+      # @option options [String] :expires_field ('expiresAt') Document field to store expiration time
+      # @option options [String] :value_field ('value') Document field to store value
+      # @option options [String] :type_field ('type') Document field to store value type
+      # @option options [::Mongo::Client] :backend Use existing backend instance
+      # @option options Other options passed to `Mongo::MongoClient#new`
+      def initialize(options = {})
+        self.default_expires = options.delete(:expires)
+        @expires_field = options.delete(:expires_field) || 'expiresAt'
+        @value_field = options.delete(:value_field) || 'value'
+        @type_field = options.delete(:type_field) || 'type'
+
+        collection = options.delete(:collection) || 'moneta'
+
+        if options.key?(:db)
+          warn('Moneta::Adapters::Mongo - the :db option is deprecated and will be removed in a future version. Use :database instead')
+        end
+        database = options.delete(:database) || options.delete(:db) || 'moneta'
+        backend = options[:backend] ||
+          begin
+            host = options.delete(:host) || '127.0.0.1'
+            port = options.delete(:port) || DEFAULT_PORT
+            options[:logger] ||= ::Logger.new(STDERR).tap do |logger|
+              logger.level = ::Logger::ERROR
+            end
+            ::Mongo::Client.new(["#{host}:#{port}"], options)
+          end
+
+        @backend = backend.use(database)
+        @collection = @backend[collection]
+        if @backend.command(buildinfo: 1).documents.first['version'] >= '2.2'
+          @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
+      end
+
+      # (see Proxy#load)
+      def load(key, options = {})
+        view = @collection.find(:$and => [
+                                  { _id: to_binary(key) },
+                                  not_expired
+                                ])
+
+        doc = view.limit(1).first
+
+        if doc
+          update_expiry(options, nil) do |expires|
+            view.update_one(:$set => { @expires_field => expires })
+          end
+
+          doc_to_value(doc)
+        end
+      end
+
+      # (see Proxy#store)
+      def store(key, value, options = {})
+        key = to_binary(key)
+        @collection.replace_one({ _id: key },
+                                value_to_doc(key, value, options),
+                                upsert: true)
+        value
+      end
+
+      # (see Proxy#each_key)
+      def each_key
+        return enum_for(:each_key) unless block_given?
+        @collection.find.each { |doc| yield from_binary(doc[:_id]) }
+        self
+      end
+
+      # (see Proxy#delete)
+      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
+          doc_to_value(doc)
+        end
+      end
+
+      # (see Proxy#increment)
+      def increment(key, amount = 1, options = {})
+        @collection.find_one_and_update({ :$and => [{ _id: to_binary(key) }, not_expired] },
+                                        { :$inc => { @value_field => amount } },
+                                        return_document: :after,
+                                        upsert: true)[@value_field]
+      rescue ::Mongo::Error::OperationFailure
+        tries ||= 0
+        (tries += 1) < 3 ? retry : raise
+      end
+
+      # (see Proxy#create)
+      def create(key, value, options = {})
+        key = to_binary(key)
+        @collection.insert_one(value_to_doc(key, value, options))
+        true
+      rescue ::Mongo::Error::OperationFailure => ex
+        raise unless ex.message =~ /^E11000 / # duplicate key error
+        false
+      end
+
+      # (see Proxy#clear)
+      def clear(options = {})
+        @collection.delete_many
+        self
+      end
+
+      # (see Proxy#close)
+      def close
+        @backend.close
+        nil
+      end
+
+      # (see Proxy#slice)
+      def slice(*keys, **options)
+        view = @collection.find(:$and => [
+                                  { _id: { :$in => keys.map(&method(:to_binary)) } },
+                                  not_expired
+                                ])
+        pairs = view.map { |doc| [from_binary(doc[:_id]), doc_to_value(doc)] }
+
+        update_expiry(options, nil) do |expires|
+          view.update_many(:$set => { @expires_field => expires })
+        end
+
+        pairs
+      end
+
+      # (see Proxy#merge!)
+      def merge!(pairs, options = {})
+        existing = Hash[slice(*pairs.map { |key, _| key })]
+        update_pairs, insert_pairs = pairs.partition { |key, _| existing.key?(key) }
+
+        @collection.insert_many(insert_pairs.map do |key, value|
+          value_to_doc(to_binary(key), value, options)
+        end)
+
+        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))
+        end
+
+        self
+      end
+
+      # (see Proxy#fetch_values)
+      def fetch_values(*keys, **options)
+        return values_at(*keys, **options) unless block_given?
+        hash = Hash[slice(*keys, **options)]
+        keys.map do |key|
+          if hash.key?(key)
+            hash[key]
+          else
+            yield key
+          end
+        end
+      end
+
+      # (see Proxy#values_at)
+      def values_at(*keys, **options)
+        hash = Hash[slice(*keys, **options)]
+        keys.map { |key| hash[key] }
+      end
+
+      private
+
+      def doc_to_value(doc)
+        case doc[@type_field]
+        when 'Hash'
+          doc = doc.dup
+          doc.delete('_id')
+          doc.delete(@type_field)
+          doc.delete(@expires_field)
+          doc
+        when 'Number'
+          doc[@value_field]
+        else
+          # In ruby_bson version 2 (and probably up), #to_s no longer returns the binary data
+          from_binary(doc[@value_field])
+        end
+      end
+
+      def value_to_doc(key, value, options)
+        case value
+        when Hash
+          value.merge('_id' => key,
+                      @type_field => 'Hash',
+                      # @expires_field must be a Time object (BSON date datatype)
+                      @expires_field => expires_at(options) || nil)
+        when Float, Integer
+          { '_id' => key,
+            @type_field => 'Number',
+            @value_field => value,
+            # @expires_field must be a Time object (BSON date datatype)
+            @expires_field => expires_at(options) || nil }
+        when String
+          intvalue = value.to_i
+          { '_id' => key,
+            @type_field => 'String',
+            @value_field => intvalue.to_s == value ? intvalue : to_binary(value),
+            # @expires_field must be a Time object (BSON date datatype)
+            @expires_field => expires_at(options) || nil }
+        else
+          raise ArgumentError, "Invalid value type: #{value.class}"
+        end
+      end
+
+      # 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(str)
+        str = str.dup if str.frozen? || str.encoding != Encoding::ASCII_8BIT
+        ::BSON::Binary.new(str)
+      end
+
+      def from_binary(binary)
+        binary.is_a?(::BSON::Binary) ? binary.data : binary.to_s
+      end
+
+      def not_expired
+        {
+          :$or => [
+            { @expires_field => nil },
+            { @expires_field => { :$gte => Time.now } }
+          ]
+        }
+      end
+
+      def update_expiry(options, default)
+        if (expires = expires_at(options, default)) != nil
+          yield(expires || nil)
+        end
+      end
     end
   end
 end