moneta 0.7.20 → 0.8.0

data/lib/active_support/cache/moneta_store.rb

@@ -4,21 +4,21 @@ module ActiveSupport
     class MonetaStore < Store
       def initialize(options = nil)
         raise ArgumentError, 'Option :store is required' unless @store = options.delete(:store)
-        @store = ::Moneta.new(@store, :expires => true) if Symbol === @store
+        @store = ::Moneta.new(@store, expires: true) if Symbol === @store
         super(options)
         extend Strategy::LocalCache
       end
 
       def increment(key, amount = 1, options = nil)
         options = merged_options(options)
-        instrument(:increment, key, :amount => amount) do
+        instrument(:increment, key, amount: amount) do
           @store.increment(namespaced_key(key, options), amount, moneta_options(options))
         end
       end
 
       def decrement(key, amount = 1, options = nil)
         options = merged_options(options)
-        instrument(:decrement, key, :amount => amount) do
+        instrument(:decrement, key, amount: amount) do
           @store.increment(namespaced_key(key, options), -amount, moneta_options(options))
         end
       end

data/lib/moneta.rb

@@ -47,6 +47,8 @@ module Moneta
     autoload :MemcachedNative, 'moneta/adapters/memcached/native'
     autoload :Memory,          'moneta/adapters/memory'
     autoload :Mongo,           'moneta/adapters/mongo'
+    autoload :MongoMoped,      'moneta/adapters/mongo/moped'
+    autoload :MongoOfficial,   'moneta/adapters/mongo/official'
     autoload :Null,            'moneta/adapters/null'
     autoload :PStore,          'moneta/adapters/pstore'
     autoload :Redis,           'moneta/adapters/redis'
@@ -98,7 +100,7 @@ module Moneta
     serializer = options.include?(:serializer) ? options.delete(:serializer) : :marshal
     key_serializer = options.include?(:key_serializer) ? options.delete(:key_serializer) : serializer
     value_serializer = options.include?(:value_serializer) ? options.delete(:value_serializer) : serializer
-    transformer = { :key => [key_serializer, :prefix], :value => [value_serializer], :prefix => options.delete(:prefix) }
+    transformer = { key: [key_serializer, :prefix], value: [value_serializer], prefix: options.delete(:prefix) }
     transformer[:value] << (Symbol === compress ? compress : :zlib) if compress
     raise ArgumentError, 'Name must be Symbol' unless Symbol === name
     case name
@@ -123,7 +125,7 @@ module Moneta
     a = Adapters.const_get(name).new(options)
     build do
       use :Logger, Hash === logger ? logger : {} if logger
-      use :Expires, :expires => options[:expires] if !a.supports?(:expires) && expires
+      use :Expires, expires: options[:expires] if !a.supports?(:expires) && expires
       use :Transformer, transformer
       use :Lock if threadsafe
       adapter a

data/lib/moneta/adapters/activerecord.rb

@@ -60,12 +60,12 @@ module Moneta
 
           table.connection_pool.with_connection do |conn|
             unless table.table_exists?
-              conn.create_table(table.table_name, :id => false) do |t|
+              conn.create_table(table.table_name, id: false) do |t|
                 # Do not use binary key (Issue #17)
-                t.string :k, :null => false
+                t.string :k, null: false
                 t.binary :v
               end
-              conn.add_index(table.table_name, :k, :unique => true)
+              conn.add_index(table.table_name, :k, unique: true)
             end
           end
 
@@ -86,14 +86,14 @@ module Moneta
       # (see Proxy#key?)
       def key?(key, options = {})
         @table.connection_pool.with_connection do
-          !@table.where(:k => key).empty?
+          !@table.where(k: key).empty?
         end
       end
 
       # (see Proxy#load)
       def load(key, options = {})
         @table.connection_pool.with_connection do
-          record = @table.select(:v).where(:k => key).first
+          record = @table.select(:v).where(k: key).first
           record && record.v
         end
       end
@@ -101,7 +101,7 @@ module Moneta
       # (see Proxy#store)
       def store(key, value, options = {})
         @table.connection_pool.with_connection do
-          record = @table.select(:k).where(:k => key).first_or_initialize
+          record = @table.select(:k).where(k: key).first_or_initialize
           record.v = value
           record.save
           value
@@ -114,7 +114,7 @@ module Moneta
       # (see Proxy#delete)
       def delete(key, options = {})
         @table.connection_pool.with_connection do
-          if record = @table.where(:k => key).first
+          if record = @table.where(k: key).first
             record.destroy
             record.v
           end
@@ -125,7 +125,7 @@ module Moneta
       def increment(key, amount = 1, options = {})
         @table.connection_pool.with_connection do
           @table.transaction do
-            if record = @table.where(:k => key).lock.first
+            if record = @table.where(k: key).lock.first
               value = Utils.to_int(record.v) + amount
               record.v = value.to_s
               record.save

data/lib/moneta/adapters/cassandra.rb

@@ -33,12 +33,12 @@ module Moneta
                                      "#{options[:host] || '127.0.0.1'}:#{options[:port] || 9160}",
                                      options)
           unless @backend.keyspaces.include?(keyspace)
-            cf_def = ::Cassandra::ColumnFamily.new(:keyspace => keyspace, :name => @cf.to_s)
-            ks_def = ::Cassandra::Keyspace.new(:name => keyspace,
-                                               :strategy_class => 'SimpleStrategy',
-                                               :strategy_options => { 'replication_factor' => '1' },
-                                               :replication_factor => 1,
-                                               :cf_defs => [cf_def])
+            cf_def = ::Cassandra::ColumnFamily.new(keyspace: keyspace, name: @cf.to_s)
+            ks_def = ::Cassandra::Keyspace.new(name: keyspace,
+                                               strategy_class: 'SimpleStrategy',
+                                               strategy_options: { 'replication_factor' => '1' },
+                                               replication_factor: 1,
+                                               cf_defs: [cf_def])
             # Wait for keyspace to be created (issue #24)
             10.times do
               begin
@@ -68,14 +68,14 @@ module Moneta
       def load(key, options = {})
         if value = @backend.get(@cf, key)
           expires = expires_value(options, nil)
-          @backend.insert(@cf, key, {'value' => value['value'] }, :ttl => expires || nil) if expires != nil
+          @backend.insert(@cf, key, {'value' => value['value'] }, ttl: expires || nil) if expires != nil
           value['value']
         end
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        @backend.insert(@cf, key, {'value' => value}, :ttl => expires_value(options) || nil)
+        @backend.insert(@cf, key, {'value' => value}, ttl: expires_value(options) || nil)
         value
       end
 

data/lib/moneta/adapters/couch.rb

@@ -30,7 +30,7 @@ module Moneta
         @value_field = options[:value_field] || 'value'
         @type_field = options[:type_field] || 'type'
         url = "http://#{options[:host] || '127.0.0.1'}:#{options[:port] || 5984}/#{options[:db] || 'moneta'}"
-        @backend = options[:backend] || ::Faraday.new(:url => url)
+        @backend = options[:backend] || ::Faraday.new(url: url)
         create_db
       end
 

data/lib/moneta/adapters/datamapper.rb

@@ -12,8 +12,8 @@ module Moneta
 
       class Store
         include ::DataMapper::Resource
-        property :k, String, :key => true, :length => 255
-        property :v, Text, :lazy => false
+        property :k, String, key: true, length: 255
+        property :v, Text, lazy: false
         self.raise_on_save_failure = true
       end
 
@@ -46,9 +46,9 @@ module Moneta
       def store(key, value, options = {})
         context do
           if record = Store.get(key)
-            record.update(:k => key, :v => value)
+            record.update(k: key, v: value)
           else
-            Store.create(:k => key, :v => value)
+            Store.create(k: key, v: value)
           end
           value
         end
@@ -60,7 +60,7 @@ module Moneta
       # (see Proxy#create)
       def create(key, value, options = {})
         context do
-          Store.create(:k => key, :v => value)
+          Store.create(k: key, v: value)
           true
         end
       rescue

data/lib/moneta/adapters/daybreak.rb

@@ -12,7 +12,7 @@ module Moneta
         @backend = options[:backend] ||
           begin
             raise ArgumentError, 'Option :file is required' unless options[:file]
-            ::Daybreak::DB.new(options[:file], :serializer => ::Daybreak::Serializer::None)
+            ::Daybreak::DB.new(options[:file], serializer: ::Daybreak::Serializer::None)
           end
       end
 

data/lib/moneta/adapters/fog.rb

@@ -16,7 +16,7 @@ module Moneta
       def initialize(options = {})
         raise ArgumentError, 'Option :dir is required' unless dir = options.delete(:dir)
         @backend = options[:backend] || ::Fog::Storage.new(options)
-        @directory = @backend.directories.get(dir) || @backend.directories.create(:key => dir)
+        @directory = @backend.directories.get(dir) || @backend.directories.create(key: dir)
       end
 
       # (see Proxy#key?)
@@ -42,7 +42,7 @@ module Moneta
       # (see Proxy#store)
       def store(key, value, options = {})
         value = value.dup if value.frozen? # HACK: Fog needs unfrozen string
-        @directory.files.create(options.merge(:key => key, :body => value))
+        @directory.files.create(options.merge(key: key, body: value))
         value
       end
 

data/lib/moneta/adapters/lmdb.rb

@@ -26,7 +26,7 @@ module Moneta
             ::LMDB.new(dir, options)
           end
 
-        @db = @backend.database(db, :create => true)
+        @db = @backend.database(db, create: true)
       end
 
       # (see Proxy#key?)

data/lib/moneta/adapters/localmemcache.rb

@@ -15,7 +15,7 @@ module Moneta
         @backend = options[:backend] ||
           begin
             raise ArgumentError, 'Option :file is required' unless options[:file]
-            ::LocalMemCache.new(:filename => options[:file])
+            ::LocalMemCache.new(filename: options[:file])
           end
       end
 

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

@@ -30,14 +30,14 @@ module Moneta
         value = @backend.get(key)
         if value
           expires = expires_value(options, nil)
-          @backend.set(key, value, expires || nil, :raw => true) if expires != nil
+          @backend.set(key, value, expires || nil, raw: true) if expires != nil
           value
         end
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        @backend.set(key, value, expires_value(options) || nil, :raw => true)
+        @backend.set(key, value, expires_value(options) || nil, raw: true)
         value
       end
 
@@ -76,7 +76,7 @@ module Moneta
 
       # (see Defaults#create)
       def create(key, value, options = {})
-        @backend.add(key, value, expires_value(options) || nil, :raw => true)
+        @backend.add(key, value, expires_value(options) || nil, raw: true)
       end
 
       # (see Proxy#close)

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.merge!(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)

data/lib/moneta/adapters/mongo.rb

@@ -1,169 +1,11 @@
-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::Mongo.new
-    #     db['key'] = {a: 1, b: 2}
-    #
-    # @api public
-    class Mongo
-      include Defaults
-      include ExpiresSupport
-
-      supports :create, :increment
-      attr_reader :backend
-
-      # @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 = {})
-        self.default_expires = options.delete(:expires)
-        collection = options.delete(:collection) || 'moneta'
-        db = options.delete(:db) || 'moneta'
-        @expires_field = options.delete(:expires_field) || 'expiresAt'
-        @value_field = options.delete(:value_field) || 'value'
-        @type_field = options.delete(:type_field) || 'type'
-        @backend = options[:backend] ||
-          begin
-            host = options.delete(:host) || '127.0.0.1'
-            port = options.delete(:port) || ::Mongo::MongoClient::DEFAULT_PORT
-            user = options.delete(:user)
-            password = options.delete(:password)
-            ::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 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
-          doc[@value_field].to_s
-        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, Fixnum
-          { '_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
-
-      def to_binary(s)
-        s = s.dup if s.frozen? # HACK: BSON::Binary needs unfrozen string
-        ::BSON::Binary.new(s)
-      end
+    begin
+      require 'moneta/adapters/mongo/official'
+      Mongo = MongoOfficial
+    rescue LoadError
+      require 'moneta/adapters/mongo/moped'
+      Mongo = MongoMoped
     end
   end
 end

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

@@ -0,0 +1,63 @@
+module Moneta
+  module Adapters
+    # @api private
+    class MongoBase
+      include Defaults
+      include ExpiresSupport
+
+      supports :create, :increment
+      attr_reader :backend
+
+      DEFAULT_PORT = 27017
+
+      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'
+      end
+
+      protected
+
+      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
+          doc[@value_field].to_s
+        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, Fixnum
+          { '_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
+    end
+  end
+end