moneta 0.7.20 → 0.8.0

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

@@ -0,0 +1,113 @@
+require 'moneta/adapters/mongo/base'
+require 'moped'
+
+module Moneta
+  module Adapters
+    # 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::MongoMoped.new
+    #     db['key'] = {a: 1, b: 2}
+    #
+    # @api public
+    class MongoMoped < MongoBase
+      # @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] :db ('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 [::Moped::Session] :backend Use existing backend instance
+      # @option options Other options passed to `Moped::Session#new`
+      def initialize(options = {})
+        super(options)
+        collection = options.delete(:collection) || 'moneta'
+        db = options.delete(:db) || 'moneta'
+        user = options.delete(:user)
+        password = options.delete(:password)
+        @backend = options[:backend] ||
+          begin
+            host = options.delete(:host) || '127.0.0.1'
+            port = options.delete(:port) || 27017
+            ::Moped::Session.new(["#{host}:#{port}"])
+          end
+        @backend.use(db)
+        @backend.login(user, password) if user && password
+        @collection = @backend[collection]
+        if @backend.command(buildinfo: 1)['version'] >= '2.2'
+          @collection.indexes.create({ @expires_field => 1 }, expireAfterSeconds: 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 = {})
+        key = to_binary(key)
+        doc = @collection.find(_id: key).one
+        if doc && (!doc[@expires_field] || doc[@expires_field] >= Time.now)
+          # @expires_field must be a Time object (BSON date datatype)
+          expires = expires_at(options, nil)
+          @collection.find(_id: key).update(:$set => { @expires_field => expires || nil }) if expires != nil
+          doc_to_value(doc)
+        end
+      end
+
+      # (see Proxy#store)
+      def store(key, value, options = {})
+        key = to_binary(key)
+        @collection.find(_id: key).upsert(value_to_doc(key, value, options))
+        value
+      end
+
+      # (see Proxy#delete)
+      def delete(key, options = {})
+        value = load(key, options)
+        @collection.find(_id: to_binary(key)).remove if value
+        value
+      end
+
+      # (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]
+        end
+      end
+
+      # (see Proxy#create)
+      def create(key, value, options = {})
+        key = to_binary(key)
+        @backend.with(safe: true, consistency: :strong) do |safe|
+          safe[@collection.name].insert(value_to_doc(key, value, options))
+        end
+        true
+      rescue ::Moped::Errors::MongoError => ex
+        raise if ex.details['code'] != 11000 # duplicate key error
+        false
+      end
+
+      # (see Proxy#clear)
+      def clear(options = {})
+        @collection.drop
+        self
+      end
+
+      protected
+
+      def to_binary(s)
+        ::Moped::BSON::Binary.new(:generic, s)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+require 'moneta/adapters/mongo/base'
+require 'mongo'
+
+module Moneta
+  module Adapters
+    # 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 MongoOfficial < MongoBase
+      # @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] :db ('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::MongoClient] :backend Use existing backend instance
+      # @option options Other options passed to `Mongo::MongoClient#new`
+      def initialize(options = {})
+        super(options)
+        collection = options.delete(:collection) || 'moneta'
+        db = options.delete(:db) || 'moneta'
+        user = options.delete(:user)
+        password = options.delete(:password)
+        @backend = options[:backend] ||
+          begin
+            host = options.delete(:host) || '127.0.0.1'
+            port = options.delete(:port) || ::Mongo::MongoClient::DEFAULT_PORT
+            ::Mongo::MongoClient.new(host, port, options)
+          end
+        db = @backend.db(db)
+        db.authenticate(user, password, true) if user && password
+        @collection = db.collection(collection)
+        if @backend.server_version >= '2.2'
+          @collection.ensure_index([[@expires_field, ::Mongo::ASCENDING]], expireAfterSeconds: 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 = {})
+        key = to_binary(key)
+        doc = @collection.find_one('_id' => key)
+        if doc && (!doc[@expires_field] || doc[@expires_field] >= Time.now)
+          expires = expires_at(options, nil)
+          @collection.update({ '_id' => key },
+                             # @expires_field must be a Time object (BSON date datatype)
+                             { '$set' => { @expires_field => expires || nil } }) if expires != nil
+          doc_to_value(doc)
+        end
+      end
+
+      # (see Proxy#store)
+      def store(key, value, options = {})
+        key = to_binary(key)
+        @collection.update({ '_id' => key },
+                           value_to_doc(key, value, options),
+                           { upsert: true })
+        value
+      end
+
+      # (see Proxy#delete)
+      def delete(key, options = {})
+        value = load(key, options)
+        @collection.remove('_id' => to_binary(key)) if value
+        value
+      end
+
+      # (see Proxy#increment)
+      def increment(key, amount = 1, options = {})
+        @collection.find_and_modify(query: { '_id' => to_binary(key) },
+                                    update: { '$inc' => { @value_field => amount } },
+                                    new: true,
+                                    upsert: true)[@value_field]
+      end
+
+      # (see Proxy#create)
+      def create(key, value, options = {})
+        key = to_binary(key)
+        @collection.insert(value_to_doc(key, value, options))
+        true
+      rescue ::Mongo::OperationFailure => ex
+        raise if ex.error_code != 11000 # duplicate key error
+        false
+      end
+
+      # (see Proxy#clear)
+      def clear(options = {})
+        @collection.remove
+        self
+      end
+
+      # (see Proxy#close)
+      def close
+        @backend.close
+        nil
+      end
+
+      protected
+
+      def to_binary(s)
+        s = s.dup if s.frozen? # HACK: BSON::Binary needs unfrozen string
+        ::BSON::Binary.new(s)
+      end
+    end
+  end
+end

data/lib/moneta/adapters/pstore.rb

@@ -77,11 +77,7 @@ module Moneta
       protected
 
       def new_store(options)
-        if RUBY_VERSION > '1.9'
-          ::PStore.new(options[:file], options[:threadsafe])
-        else
-          ::PStore.new(options[:file])
-        end
+        ::PStore.new(options[:file], options[:threadsafe])
       end
     end
   end

data/lib/moneta/adapters/restclient.rb

@@ -14,7 +14,7 @@ module Moneta
       # @option options [Faraday connection] :backend Use existing backend instance
       def initialize(options = {})
         raise ArgumentError, 'Option :url is required' unless url = options[:url]
-        @backend = options[:backend] || ::Faraday.new(:url => url)
+        @backend = options[:backend] || ::Faraday.new(url: url)
       end
 
       # (see Proxy#key?)

data/lib/moneta/adapters/sequel.rb

@@ -27,7 +27,7 @@ module Moneta
             ::Sequel.connect(db, options)
           end
         @backend.create_table?(table) do
-          String :k, :null => false, :primary_key => true
+          String :k, null: false, primary_key: true
           Blob :v
         end
         @table = @backend[table]
@@ -35,21 +35,21 @@ module Moneta
 
       # (see Proxy#key?)
       def key?(key, options = {})
-        @table[:k => key] != nil
+        @table[k: key] != nil
       end
 
       # (see Proxy#load)
       def load(key, options = {})
-        record = @table[:k => key]
+        record = @table[k: key]
         record && record[:v]
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
         begin
-          @table.insert(:k => key, :v => blob(value))
+          @table.insert(k: key, v: blob(value))
         rescue UniqueConstraintViolation
-          @table.where(:k => key).update(:v => blob(value))
+          @table.where(k: key).update(v: blob(value))
         end
         value
       rescue ::Sequel::DatabaseError
@@ -59,7 +59,7 @@ module Moneta
 
       # (see Proxy#store)
       def create(key, value, options = {})
-        @table.insert(:k => key, :v => blob(value))
+        @table.insert(k: key, v: blob(value))
         true
       rescue UniqueConstraintViolation
         false
@@ -69,12 +69,12 @@ module Moneta
       def increment(key, amount = 1, options = {})
         @backend.transaction do
           locked_table = @table.for_update
-          if record = locked_table[:k => key]
+          if record = locked_table[k: key]
             value = Utils.to_int(record[:v]) + amount
-            locked_table.where(:k => key).update(:v => blob(value.to_s))
+            locked_table.where(k: key).update(v: blob(value.to_s))
             value
           else
-            locked_table.insert(:k => key, :v => blob(amount.to_s))
+            locked_table.insert(k: key, v: blob(amount.to_s))
             amount
           end
         end
@@ -87,7 +87,7 @@ module Moneta
       # (see Proxy#delete)
       def delete(key, options = {})
         if value = load(key, options)
-          @table.filter(:k => key).delete
+          @table.filter(k: key).delete
           value
         end
       end

data/lib/moneta/cache.rb

@@ -4,7 +4,7 @@ module Moneta
   # @example Add `Moneta::Cache` to proxy stack
   #   Moneta.build do
   #     use(:Cache) do
-  #      adapter { adapter :File, :dir => 'data' }
+  #      adapter { adapter :File, dir: 'data' }
   #      cache { adapter :Memory }
   #     end
   #   end

data/lib/moneta/logger.rb

@@ -64,10 +64,10 @@ module Moneta
 
     def wrap(method, *args)
       ret = yield
-      @logger.log(:method => method, :args => args, :return => (method == :clear ? 'self' : ret))
+      @logger.log(method: method, args: args, return: (method == :clear ? 'self' : ret))
       ret
     rescue Exception => error
-      @logger.log(:method => method, :args => args, :error => error)
+      @logger.log(method: method, args: args, error: error)
       raise
     end
   end

data/lib/moneta/mixins.rb

@@ -17,14 +17,14 @@ module Moneta
       options ? OptionMerger.new(adapter, options) : adapter
     end
 
-    # Return Moneta store with default option :raw => true
+    # Return Moneta store with default option raw: true
     #
     # @return [OptionMerger]
     # @api public
     def raw
       @raw_store ||=
         begin
-          store = with(:raw => true, :only => [:load, :store, :create, :delete])
+          store = with(raw: true, only: [:load, :store, :create, :delete])
           store.instance_variable_set(:@raw_store, store)
           store
         end
@@ -36,7 +36,7 @@ module Moneta
     # @return [OptionMerger]
     # @api public
     def prefix(prefix)
-      with(:prefix => prefix, :except => :clear)
+      with(prefix: prefix, except: :clear)
     end
 
     # Return Moneta store with default expiration time
@@ -45,7 +45,7 @@ module Moneta
     # @return [OptionMerger]
     # @api public
     def expires(expires)
-      with(:expires => expires, :only => [:store, :create, :increment])
+      with(expires: expires, only: [:store, :create, :increment])
     end
   end
 

data/lib/moneta/shared.rb

@@ -3,9 +3,9 @@ module Moneta
   #
   # @example Share a store
   #   Moneta.build do
-  #     use :Transformer, :key => :marshal, :value => :marshal
+  #     use :Transformer, key: :marshal, value: :marshal
   #     use :Shared do
-  #       adapter :GDBM, :file => 'shared.db'
+  #       adapter :GDBM, file: 'shared.db'
   #     end
   #   end
   #

data/lib/moneta/stack.rb

@@ -6,8 +6,8 @@ module Moneta
   #   Moneta.build do
   #     use(:Stack) do
   #       add { adapter :Redis }
-  #       add { adapter :File, :dir => 'data' }
-  #       add { adapter :File, :dir => 'replicate' }
+  #       add { adapter :File, dir: 'data' }
+  #       add { adapter :File, dir: 'replicate' }
   #     end
   #   end
   #

data/lib/moneta/synchronize.rb

@@ -80,7 +80,7 @@ module Moneta
     protected
 
     def enter_primitive
-      @store.create(@lock, '', :expires => false)
+      @store.create(@lock, '', expires: false)
     end
 
     def leave_primitive
@@ -105,7 +105,7 @@ module Moneta
     def initialize(store, counter, max = 1)
       raise 'Store must support feature :increment' unless store.supports?(:increment)
       @store, @counter, @max = store, counter, max
-      @store.increment(@counter, 0, :expires => false) # Ensure that counter exists
+      @store.increment(@counter, 0, expires: false) # Ensure that counter exists
     end
 
     protected

data/lib/moneta/transformer.rb

@@ -4,17 +4,17 @@ module Moneta
   #
   # @example Add `Moneta::Transformer` to proxy stack
   #   Moneta.build do
-  #     transformer :key => [:marshal, :escape], :value => [:marshal]
-  #     adapter :File, :dir => 'data'
+  #     transformer key: [:marshal, :escape], value: [:marshal]
+  #     adapter :File, dir: 'data'
   #   end
   #
   # @example Bypass serialization
-  #   store.store('key', 'value', :raw => true)
+  #   store.store('key', 'value', raw: true)
   #   store['key'] # raises an Exception
-  #   store.load('key', :raw => true) # returns 'value'
+  #   store.load('key', raw: true) # returns 'value'
   #
   #   store['key'] = 'value'
-  #   store.load('key', :raw => true) # returns "\x04\bI\"\nvalue\x06:\x06ET"
+  #   store.load('key', raw: true) # returns "\x04\bI\"\nvalue\x06:\x06ET"
   #
   # @api public
   class Transformer < Proxy