moneta 1.0.0 → 1.5.1

data/.travis.yml

@@ -1,55 +0,0 @@
-language: ruby
-rvm:
-  - 2.1.0
-  - 2.0.0
-  - 1.9.3
-  - jruby-19mode
-  - rbx-19mode
-services:
-  - riak
-  - couchdb
-  - redis
-  - cassandra
-  - memcached
-  - mongodb
-before_install:
-  - gem install bundler -v '~> 1.10'
-  #- script/install-kyotocabinet
-  - sudo apt-get install -qq libtokyocabinet8 libtokyocabinet-dev liblzo2-dev libtdb-dev libleveldb-dev tokyotyrant
-  - script/start-services
-cache: bundler
-before_script:
-  - mysql -e 'create database moneta;'
-  - mysql -e 'create database moneta_activerecord1;'
-  - mysql -e 'create database moneta_activerecord2;'
-env:
-  global:
-    - secure: "dtM4n7FP8P0UI9Iq+nsvQ7/yfDqsxhfCO9i8zMxm/f9Kxj5Z/4C7jsXsLA+e\n/7FZ9+ld2QjPSPU0LUiDpj/z81bxyZHwqocQ7Nb0DVvO3JRHpr4/iBQQQHd3\n0jvou3mRbu5mBlUjf1/ALaZA+b+vcnsF9fd86UnkY+ChriylGnM="
-  matrix:
-    - "SCRIPT='parallel-tests 1/10'"
-    - "SCRIPT='parallel-tests 2/10'"
-    - "SCRIPT='parallel-tests 3/10'"
-    - "SCRIPT='parallel-tests 4/10'"
-    - "SCRIPT='parallel-tests 5/10'"
-    - "SCRIPT='parallel-tests 6/10'"
-    - "SCRIPT='parallel-tests 7/10'"
-    - "SCRIPT='parallel-tests 8/10'"
-    - "SCRIPT='parallel-tests 9/10'"
-    - "SCRIPT='parallel-tests 10/10'"
-    - "SCRIPT='parallel-tests unstable'"
-    - "SCRIPT='benchmarks uniform_small'"
-    - "SCRIPT='benchmarks uniform_medium'"
-    - "SCRIPT='benchmarks uniform_large'"
-    - "SCRIPT='benchmarks normal_small'"
-    - "SCRIPT='benchmarks normal_medium'"
-    - "SCRIPT='benchmarks normal_large'"
-matrix:
-  allow_failures:
-    - rvm: jruby-19mode
-    - rvm: rbx-19mode
-    - env: "SCRIPT='parallel-tests unstable'"
-script: "eval bundle exec ruby script/$SCRIPT"
-branches:
-  only:
-    - master
-    - travis

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

@@ -1,78 +0,0 @@
-require 'bson'
-
-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
-          # In ruby_bson version 2 (and probably up), #to_s no longer returns the binary data
-          if doc[@value_field].is_a? ::BSON::Binary and defined? ::BSON::VERSION and ::BSON::VERSION[0].to_i >= 2
-            doc[@value_field].data
-          else
-            doc[@value_field].to_s
-          end
-        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
-
-      # 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)
-      end
-    end
-  end
-end

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

@@ -1,107 +0,0 @@
-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) || DEFAULT_PORT
-            ::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.find.remove_all
-        self
-      end
-    end
-  end
-end

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

@@ -1,117 +0,0 @@
-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::Client] :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'
-        @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.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)
-        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).limit(1).first
-        if doc && (!doc[@expires_field] || doc[@expires_field] >= Time.now)
-          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?
-          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#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
-        then
-          doc_to_value(doc)
-        end
-      end
-
-      # (see Proxy#increment)
-      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]
-      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
-    end
-  end
-end

data/lib/moneta/mixins.rb

@@ -1,343 +0,0 @@
-module Moneta
-  # @api private
-  module OptionSupport
-    # Return Moneta store with default options or additional proxies
-    #
-    # @param [Hash] options Options to merge
-    # @return [Moneta store]
-    #
-    # @api public
-    def with(options = nil, &block)
-      adapter = self
-      if block
-        builder = Builder.new(&block)
-        builder.adapter(adapter)
-        adapter = builder.build.last
-      end
-      options ? OptionMerger.new(adapter, options) : adapter
-    end
-
-    # 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.instance_variable_set(:@raw_store, store)
-          store
-        end
-    end
-
-    # Return Moneta store with default prefix option
-    #
-    # @param [String] prefix Key prefix
-    # @return [OptionMerger]
-    # @api public
-    def prefix(prefix)
-      with(prefix: prefix, except: :clear)
-    end
-
-    # Return Moneta store with default expiration time
-    #
-    # @param [Integer] expires Default expiration time
-    # @return [OptionMerger]
-    # @api public
-    def expires(expires)
-      with(expires: expires, only: [:store, :create, :increment])
-    end
-  end
-
-  # Simple interface to key/value stores with Hash-like interface.
-  # @api public
-  module Defaults
-    include OptionSupport
-
-    # @api private
-    module ClassMethods
-      # Returns features list
-      #
-      # @return [Array<Symbol>] list of features
-      def features
-        @features ||= superclass.respond_to?(:features) ? superclass.features : [].freeze
-      end
-
-      # Declares that this adapter supports the given feature.
-      #
-      # @example
-      #   class MyAdapter
-      #     include Moneta::Defaults
-      #     supports :create
-      #     def create(key, value, options = {})
-      #       # implement create!
-      #     end
-      #   end
-      def supports(*features)
-        @features = (self.features + features).uniq.freeze
-      end
-    end
-
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    # Exists the value with key
-    #
-    # @param [Object] key
-    # @param [Hash] options
-    # @option options [Integer] :expires Update expiration time (See {Expires})
-    # @option options [String] :prefix Prefix key (See {Transformer})
-    # @option options Other options as defined by the adapters or middleware
-    # @return [Boolean]
-    # @api public
-    def key?(key, options = {})
-      load(key, options) != nil
-    end
-
-    # Atomically increment integer value with key
-    #
-    # This method also accepts negative amounts.
-    #
-    # @note Not every Moneta store implements this method,
-    #       a NotImplementedError is raised if it is not supported.
-    # @param [Object] key
-    # @param [Integer] amount
-    # @param [Hash] options
-    # @option options [String] :prefix Prefix key (See {Transformer})
-    # @option options Other options as defined by the adapters or middleware
-    # @return [Object] value from store
-    # @api public
-    def increment(key, amount = 1, options = {})
-      raise NotImplementedError, 'increment is not supported'
-    end
-
-    # Atomically decrement integer value with key
-    #
-    # This is just syntactic sugar for calling #increment with a negative value.
-    #
-    # This method also accepts negative amounts.
-    #
-    # @param [Object] key
-    # @param [Integer] amount
-    # @param [Hash] options
-    # @option options [String] :prefix Prefix key (See {Transformer})
-    # @option options Other options as defined by the adapters or middleware
-    # @return [Object] value from store
-    # @api public
-    def decrement(key, amount = 1, options = {})
-      increment(key, -amount, options)
-    end
-
-    # Explicitly close the store
-    # @return nil
-    # @api public
-    def close
-    end
-
-    # Fetch a value with a key
-    #
-    # @overload fetch(key, options = {}, &block)
-    #   retrieve a key. if the key is not available, execute the
-    #   block and return its return value.
-    #   @param [Object] key
-    #   @param [Hash] options
-    #   @option options [Integer] :expires Update expiration time (See {Expires})
-    #   @option options [Boolean] :raw Raw access without value transformation (See {Transformer})
-    #   @option options [String] :prefix Prefix key (See {Transformer})
-    #   @return [Object] value from store
-    #
-    # @overload fetch(key, default, options = {})
-    #   retrieve a key. if the key is not available, return the default value.
-    #   @param [Object] key
-    #   @param [Object] default Default value
-    #   @param [Hash] options
-    #   @option options [Integer] :expires Update expiration time (See {Expires})
-    #   @option options [Boolean] :raw Raw access without value transformation (See {Transformer})
-    #   @option options [String] :prefix Prefix key (See {Transformer})
-    #   @return [Object] value from store
-    #
-    # @api public
-    def fetch(key, default = nil, options = nil)
-      if block_given?
-        raise ArgumentError, 'Only one argument accepted if block is given' if options
-        result = load(key, default || {})
-        result == nil ? yield(key) : result
-      else
-        result = load(key, options || {})
-        result == nil ? default : result
-      end
-    end
-
-    # Fetch value with key. Return nil if the key doesn't exist
-    #
-    # @param [Object] key
-    # @return [Object] value
-    # @api public
-    def [](key)
-      load(key)
-    end
-
-    # Store value with key
-    #
-    # @param [Object] key
-    # @param [Object] value
-    # @return value
-    # @api public
-    def []=(key, value)
-      store(key, value)
-    end
-
-    # Atomically sets a key to value if it's not set.
-    #
-    # @note Not every Moneta store implements this method,
-    #       a NotImplementedError is raised if it is not supported.
-    # @param [Object] key
-    # @param [Object] value
-    # @param [Hash] options
-    # @option options [Integer] :expires Update expiration time (See {Expires})
-    # @option options [Boolean] :raw Raw access without value transformation (See {Transformer})
-    # @option options [String] :prefix Prefix key (See {Transformer})
-    # @return [Boolean] key was set
-    # @api public
-    def create(key, value, options = {})
-      raise NotImplementedError, 'create is not supported'
-    end
-
-    # Returns features list
-    #
-    # @return [Array<Symbol>] list of features
-    def features
-      self.class.features
-    end
-
-    # Return true if adapter supports the given feature.
-    #
-    # @return [Boolean]
-    def supports?(feature)
-      features.include?(feature)
-    end
-  end
-
-  # @api private
-  module IncrementSupport
-    # (see Defaults#increment)
-    def increment(key, amount = 1, options = {})
-      value = Utils.to_int(load(key, options)) + amount
-      store(key, value.to_s, options)
-      value
-    end
-
-    def self.included(base)
-      base.supports(:increment) if base.respond_to?(:supports)
-    end
-  end
-
-  # Implements simple create using key? and store.
-  #
-  # This is sufficient for non-shared stores or if atomicity is not required.
-  # @api private
-  module CreateSupport
-    # (see Defaults#create)
-    def create(key, value, options = {})
-      if key? key
-        false
-      else
-        store(key, value, options)
-        true
-      end
-    end
-
-    def self.included(base)
-      base.supports(:create) if base.respond_to?(:supports)
-    end
-  end
-
-  # @api private
-  module HashAdapter
-    attr_reader :backend
-
-    # (see Proxy#key?)
-    def key?(key, options = {})
-      @backend.has_key?(key)
-    end
-
-    # (see Proxy#load)
-    def load(key, options = {})
-      @backend[key]
-    end
-
-    # (see Proxy#store)
-    def store(key, value, options = {})
-      @backend[key] = value
-    end
-
-    # (see Proxy#delete)
-    def delete(key, options = {})
-      @backend.delete(key)
-    end
-
-    # (see Proxy#clear)
-    def clear(options = {})
-      @backend.clear
-      self
-    end
-  end
-
-  # This mixin handles the calculation of expiration times.
-  #
-  #
-  module ExpiresSupport
-    attr_accessor :default_expires
-
-    protected
-
-    # Calculates the time when something will expire.
-    #
-    # This method considers false and 0 as "no-expire" and every positive
-    # number as a time to live in seconds.
-    #
-    # @param [Hash] options Options hash
-    # @option options [0,false,nil,Numeric] :expires expires value given by user
-    # @param [0,false,nil,Numeric] default default expiration time
-    #
-    # @return [false] if it should not expire
-    # @return [Time] the time when something should expire
-    # @return [nil] if it is not known
-    def expires_at(options, default = @default_expires)
-      value = expires_value(options, default)
-      Numeric === value ? Time.now + value : value
-    end
-
-    # Calculates the number of seconds something should last.
-    #
-    # This method considers false and 0 as "no-expire" and every positive
-    # number as a time to live in seconds.
-    #
-    # @param [Hash] options Options hash
-    # @option options [0,false,nil,Numeric] :expires expires value given by user
-    # @param [0,false,nil,Numeric] default default expiration time
-    #
-    # @return [false] if it should not expire
-    # @return [Numeric] seconds until expiration
-    # @return [nil] if it is not known
-    def expires_value(options, default = @default_expires)
-      case value = options[:expires]
-      when 0, false
-        false
-      when nil
-        default ? default.to_i : nil
-      when Numeric
-        value = value.to_i
-        raise ArgumentError, ":expires must be a positive value, got #{value}" if value < 0
-        value
-      else
-        raise ArgumentError, ":expires must be Numeric or false, got #{value.inspect}"
-      end
-    end
-
-    def self.included(base)
-      base.supports(:expires) if base.respond_to?(:supports)
-    end
-  end
-end