moneta 0.6.0 → 0.7.0

data/lib/moneta/adapters/memory.rb

@@ -0,0 +1,10 @@
+module Moneta
+  module Adapters
+    # Memory backend using a hash to store the entries
+    # @api public
+    class Memory < Base
+      include Mixins::IncrementSupport
+      include Mixins::HashAdapter
+    end
+  end
+end

data/lib/moneta/adapters/mongo.rb

@@ -0,0 +1,50 @@
+require 'mongo'
+
+module Moneta
+  module Adapters
+    # MongoDB backend
+    # @api public
+    class Mongo < Base
+      # Constructor
+      #
+      # @param [Hash] options
+      #
+      # Options:
+      # * :collection - MongoDB collection name (default moneta)
+      # * :host - MongoDB server host (default localhost)
+      # * :port - MongoDB server port (default mongodb default port)
+      # * :db - MongoDB database (default moneta)
+      def initialize(options = {})
+        collection = options.delete(:collection) || 'moneta'
+        host = options.delete(:host) || 'localhost'
+        port = options.delete(:port) || ::Mongo::Connection::DEFAULT_PORT
+        db = options.delete(:db) || 'moneta'
+        connection = ::Mongo::Connection.new(host, port, options)
+        @collection = connection.db(db).collection(collection)
+      end
+
+      def load(key, options = {})
+        value = @collection.find_one('_id' => key)
+        value && value['value'].to_s
+      end
+
+      def delete(key, options = {})
+        value = load(key, options)
+        @collection.remove('_id' => key) if value
+        value
+      end
+
+      def store(key, value, options = {})
+        @collection.update({ '_id' => key },
+                           { '_id' => key, 'value' => ::BSON::Binary.new(value) },
+                           { :upsert => true })
+        value
+      end
+
+      def clear(options = {})
+        @collection.remove
+        self
+      end
+    end
+  end
+end

data/lib/moneta/adapters/null.rb

@@ -0,0 +1,30 @@
+module Moneta
+  module Adapters
+    # Null backend which doesn't store anything
+    # @api public
+    class Null < Base
+      def initialize(options = {})
+      end
+
+      def key?(key, options = {})
+        false
+      end
+
+      def load(key, options = {})
+        nil
+      end
+
+      def store(key, value, options = {})
+        value
+      end
+
+      def delete(key, options = {})
+        nil
+      end
+
+      def clear(options = {})
+        self
+      end
+    end
+  end
+end

data/lib/moneta/adapters/pstore.rb

@@ -0,0 +1,69 @@
+require 'pstore'
+
+module Moneta
+  module Adapters
+    # PStore backend
+    # @api public
+    class PStore < Base
+      # Constructor
+      #
+      # @param [Hash] options
+      #
+      # Options:
+      # * :file - PStore file
+      def initialize(options = {})
+        raise ArgumentError, 'Option :file is required' unless options[:file]
+        FileUtils.mkpath(::File.dirname(options[:file]))
+        @pstore = new_store(options)
+      end
+
+      def key?(key, options = {})
+        @pstore.transaction(true) { @pstore.root?(key) }
+      end
+
+      def load(key, options = {})
+        @pstore.transaction(true) { @pstore[key] }
+      end
+
+      def store(key, value, options = {})
+        @pstore.transaction { @pstore[key] = value }
+      end
+
+      def delete(key, options = {})
+        @pstore.transaction { @pstore.delete(key) }
+      end
+
+      def increment(key, amount = 1, options = {})
+        @pstore.transaction do
+          value = @pstore[key]
+          intvalue = value.to_i
+          raise 'Tried to increment non integer value' unless value == nil || intvalue.to_s == value.to_s
+          intvalue += amount
+          @pstore[key] = intvalue.to_s
+          intvalue
+        end
+      end
+
+      def clear(options = {})
+        @pstore.transaction do
+          @pstore.roots.each do |key|
+            @pstore.delete(key)
+          end
+        end
+        self
+      end
+
+      protected
+
+      if RUBY_VERSION > '1.9'
+        def new_store(options)
+          ::PStore.new(options[:file], options[:threadsafe])
+        end
+      else
+        def new_store(options)
+          ::PStore.new(options[:file])
+        end
+      end
+    end
+  end
+end

data/lib/moneta/adapters/redis.rb

@@ -0,0 +1,68 @@
+require 'redis'
+
+module Moneta
+  module Adapters
+    # Redis backend
+    # @api public
+    class Redis < Base
+      # Constructor
+      #
+      # @param [Hash] options
+      #
+      # Options:
+      # * :expires - Default expiration time (default none)
+      # * Other options passed to Redis#new
+      def initialize(options = {})
+        @expires = options.delete(:expires)
+        @redis = ::Redis.new(options)
+      end
+
+      def key?(key, options = {})
+        if @redis.exists(key)
+          if expires = options[:expires]
+            @redis.expire(key, expires)
+          end
+          true
+        else
+          false
+        end
+      end
+
+      def load(key, options = {})
+        value = @redis.get(key)
+        if value && (expires = options[:expires])
+          @redis.expire(key, expires)
+        end
+        value
+      end
+
+      def store(key, value, options = {})
+        if expires = (options[:expires] || @expires)
+          @redis.setex(key, expires, value)
+        else
+          @redis.set(key, value)
+        end
+        value
+      end
+
+      def delete(key, options = {})
+        if value = load(key, options)
+          @redis.del(key)
+          value
+        end
+      end
+
+      def increment(key, amount = 1, options = {})
+        value = @redis.incrby(key, amount)
+        expires = (options[:expires] || @expires)
+        @redis.expire(key, expires) if expires
+        value
+      end
+
+      def clear(options = {})
+        @redis.flushdb
+        self
+      end
+    end
+  end
+end

data/lib/moneta/adapters/riak.rb

@@ -0,0 +1,57 @@
+# Copyright: 2011 TMX Credit
+# Author: Potapov Sergey (aka Blake)
+
+require 'riak'
+
+module Moneta
+  module Adapters
+    # Riak backend
+    # @api public
+    class Riak < Base
+      # Constructor
+      #
+      # @param [Hash] options
+      #
+      # Options:
+      # * :bucket - Bucket name (default moneta)
+      # * :content_type - Default content type (default application/octet-stream)
+      # * All other options passed to Riak::Client#new
+      def initialize(options = {})
+        bucket = options.delete(:bucket) || 'moneta'
+        @content_type = options.delete(:content_type) || 'application/octet-stream'
+        @bucket = ::Riak::Client.new(options).bucket(bucket)
+      end
+
+      def key?(key, options = {})
+        @bucket.exists?(key, options)
+      end
+
+      def load(key, options = {})
+        @bucket.get(key, options).raw_data
+      rescue ::Riak::FailedRequest => ex
+        nil
+      end
+
+      def delete(key, options = {})
+        value = load(key, options)
+        @bucket.delete(key, options)
+        value
+      end
+
+      def store(key, value, options = {})
+        obj = ::Riak::RObject.new(@bucket, key)
+        obj.content_type = options[:content_type] || @content_type
+        obj.raw_data = value
+        obj.store(options)
+        value
+      end
+
+      def clear(options = {})
+        @bucket.keys do |keys|
+          keys.each{ |key| @bucket.delete(key) }
+        end
+        self
+      end
+    end
+  end
+end

data/lib/moneta/adapters/sdbm.rb

@@ -0,0 +1,35 @@
+require 'sdbm'
+
+module Moneta
+  module Adapters
+    # SDBM backend
+    # @api public
+    class SDBM < Memory
+      # Constructor
+      #
+      # @param [Hash] options
+      #
+      # Options:
+      # * :file - Database file
+      def initialize(options = {})
+        raise ArgumentError, 'Option :file is required' unless options[:file]
+        @hash = ::SDBM.new(options[:file])
+      end
+
+      def close
+        @hash.close
+        nil
+      end
+
+      def store(key, value, options = {})
+        super
+        value
+      rescue SDBMError
+        # SDBM is not very robust!
+        # You shouldn't put to much data into it, otherwise
+        # it might raise a SDBMError.
+        value
+      end
+    end
+  end
+end

data/lib/moneta/adapters/sequel.rb

@@ -0,0 +1,79 @@
+require 'sequel'
+
+module Moneta
+  module Adapters
+    # Sequel backend
+    # @api public
+    class Sequel < Base
+      # Constructor
+      #
+      # @param [Hash] options
+      #
+      # Options:
+      # * :db - Sequel database
+      # * :table - Table name (default :moneta)
+      # * All other options passed to Sequel#connect
+      def initialize(options = {})
+        raise ArgumentError, 'Option :db is required' unless db = options.delete(:db)
+        table = options.delete(:table) || :moneta
+        @db = ::Sequel.connect(db, options)
+        @db.create_table?(table) do
+          String :k, :null => false, :primary_key => true
+          String :v
+        end
+        @table = @db[table]
+      end
+
+      def key?(key, options = {})
+        @table[:k => key] != nil
+      end
+
+      def load(key, options = {})
+        record = @table[:k => key]
+        record && record[:v]
+      end
+
+      def store(key, value, options = {})
+        @db.transaction do
+          if key?(key, options)
+            @table.update(:k => key, :v => value)
+          else
+            @table.insert(:k => key, :v => value)
+          end
+          value
+        end
+      end
+
+      def increment(key, amount = 1, options = {})
+        @db.transaction do
+          locked_table = @table.for_update
+          if record = locked_table[:k => key]
+            value = record[:v]
+            intvalue = value.to_i
+            raise 'Tried to increment non integer value' unless value == nil || intvalue.to_s == value.to_s
+            intvalue += amount
+            locked_table.update(:k => key, :v => intvalue.to_s)
+            intvalue
+          else
+            locked_table.insert(:k => key, :v => amount.to_s)
+            amount
+          end
+        end
+      end
+
+      def delete(key, options = {})
+        @db.transaction do
+          if value = load(key, options)
+            @table.filter(:k => key).delete
+            value
+          end
+        end
+      end
+
+      def clear(options = {})
+        @table.delete
+        self
+      end
+    end
+  end
+end

data/lib/moneta/adapters/sqlite.rb

@@ -0,0 +1,65 @@
+require 'sqlite3'
+
+module Moneta
+  module Adapters
+    # Sqlite3 backend
+    # @api public
+    class Sqlite < Base
+      include Mixins::IncrementSupport
+
+      # Constructor
+      #
+      # @param [Hash] options
+      #
+      # Options:
+      # * :file - Database file
+      # * :table - Table name (default moneta)
+      def initialize(options = {})
+        raise ArgumentError, 'Option :file is required' unless options[:file]
+        table = options[:table] || 'moneta'
+        @db = ::SQLite3::Database.new(options[:file])
+        @db.execute("create table if not exists #{table} (k blob not null primary key, v blob)")
+        @stmts =
+          [@select = @db.prepare("select v from #{table} where k = ?"),
+           @replace = @db.prepare("replace into #{table} values (?, ?)"),
+           @delete = @db.prepare("delete from #{table} where k = ?"),
+           @clear = @db.prepare("delete from #{table}")]
+      end
+
+      def key?(key, options = {})
+        !@select.execute!(key).empty?
+      end
+
+      def load(key, options = {})
+        rows = @select.execute!(key)
+        rows.empty? ? nil : rows.first.first
+      end
+
+      def store(key, value, options = {})
+        @replace.execute!(key, value)
+        value
+      end
+
+      def delete(key, options = {})
+        value = load(key, options)
+        @delete.execute!(key)
+        value
+      end
+
+      def increment(key, amount = 1, options = {})
+        @db.transaction(:exclusive) { return super }
+      end
+
+      def clear(options = {})
+        @clear.execute!
+        self
+      end
+
+      def close
+        @stmts.each {|s| s.close }
+        @db.close
+        nil
+      end
+    end
+  end
+end