moneta 0.7.9 → 0.7.10

data/lib/moneta/adapters/restclient.rb

@@ -7,48 +7,51 @@ module Moneta
     class RestClient
       include Defaults
 
+      attr_reader :backend
+
       # @param [Hash] options
       # @option options [String] :url URL
+      # @option options [::Net::HTTP] :backend Use existing backend instance
       def initialize(options = {})
         raise ArgumentError, 'Option :url is required' unless url = options[:url]
         url = URI(url)
         @path = url.path
-        @client = ::Net::HTTP.start(url.host, url.port)
+        @backend = options[:backend] || ::Net::HTTP.start(url.host, url.port)
       end
 
       # (see Proxy#key?)
       def key?(key, options = {})
-        response = @client.request_head(@path + key)
+        response = @backend.request_head(@path + key)
         response.code == '200'
       end
 
       # (see Proxy#load)
       def load(key, options = {})
-        response = @client.request_get(@path + key)
+        response = @backend.request_get(@path + key)
         response.code == '200' ? response.body : nil
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        response = @client.request_post(@path + key, value)
+        response = @backend.request_post(@path + key, value)
         raise "HTTP error #{response.code}" unless response.code == '200'
         value
       end
 
       # (see Proxy#delete)
       def delete(key, options = {})
-        response = @client.request(::Net::HTTP::Delete.new(@path + key))
+        response = @backend.request(::Net::HTTP::Delete.new(@path + key))
         response.code == '200' ? response.body : nil
       end
 
       # (see Proxy#clear)
       def clear(options = {})
-        @client.request(::Net::HTTP::Delete.new(@path))
+        @backend.request(::Net::HTTP::Delete.new(@path))
         self
       end
 
       def close
-        @client.finish
+        @backend.finish
         nil
       end
     end

data/lib/moneta/adapters/riak.rb

@@ -10,14 +10,18 @@ module Moneta
     class Riak
       include Defaults
 
+      attr_reader :backend
+
       # @param [Hash] options
       # @option options [String] :bucket ('moneta') Bucket name
       # @option options [String] :content_type ('application/octet-stream') Default content type
       # @option options All other options passed to `Riak::Client#new`
+      # @option options [::Riak::Client] :backend Use existing backend instance
       def initialize(options = {})
         bucket = options.delete(:bucket) || 'moneta'
         @content_type = options.delete(:content_type) || 'application/octet-stream'
-        @bucket = ::Riak::Client.new(options).bucket(bucket)
+        @backend = options[:backend] || ::Riak::Client.new(options)
+        @bucket = @backend.bucket(bucket)
       end
 
       # (see Proxy#key?)

data/lib/moneta/adapters/sdbm.rb

@@ -7,14 +7,18 @@ module Moneta
     class SDBM < Memory
       # @param [Hash] options
       # @option options [String] :file Database file
+      # @option options [::SDBM] :backend Use existing backend instance
       def initialize(options = {})
-        raise ArgumentError, 'Option :file is required' unless options[:file]
-        @hash = ::SDBM.new(options[:file])
+        @backend = options[:backend] ||
+          begin
+            raise ArgumentError, 'Option :file is required' unless options[:file]
+            ::SDBM.new(options[:file])
+          end
       end
 
       # (see Proxy#close)
       def close
-        @hash.close
+        @backend.close
         nil
       end
     end

data/lib/moneta/adapters/sequel.rb

@@ -8,20 +8,25 @@ module Moneta
       include Defaults
 
       supports :create, :increment
+      attr_reader :backend
 
       # @param [Hash] options
       # @option options [String] :db Sequel database
       # @option options [String/Symbol] :table (:moneta) Table name
       # @option options All other options passed to `Sequel#connect`
+      # @option options [Sequel connection] :backend Use existing backend instance
       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
+        @backend = options[:backend] ||
+          begin
+            raise ArgumentError, 'Option :db is required' unless db = options.delete(:db)
+            ::Sequel.connect(db, options)
+          end
+        @backend.create_table?(table) do
           String :k, :null => false, :primary_key => true
           String :v
         end
-        @table = @db[table]
+        @table = @backend[table]
       end
 
       # (see Proxy#key?)
@@ -37,7 +42,7 @@ module Moneta
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        @db.transaction do
+        @backend.transaction do
           begin
             @table.insert(:k => key, :v => value)
           rescue ::Sequel::DatabaseError
@@ -52,7 +57,7 @@ module Moneta
 
       # (see Proxy#store)
       def create(key, value, options = {})
-        @db.transaction do
+        @backend.transaction do
           @table.insert(:k => key, :v => value)
         end
         true
@@ -64,7 +69,7 @@ module Moneta
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
-        @db.transaction do
+        @backend.transaction do
           locked_table = @table.for_update
           if record = locked_table[:k => key]
             value = Utils.to_int(record[:v]) + amount
@@ -79,7 +84,7 @@ module Moneta
 
       # (see Proxy#delete)
       def delete(key, options = {})
-        @db.transaction do
+        @backend.transaction do
           if value = load(key, options)
             @table.filter(:k => key).delete
             value

data/lib/moneta/adapters/sqlite.rb

@@ -9,21 +9,26 @@ module Moneta
       include IncrementSupport
 
       supports :create
+      attr_reader :backend
 
       # @param [Hash] options
       # @option options [String] :file Database file
       # @option options [String] :table ('moneta') Table name
+      # @option options [::Sqlite3::Database] :backend Use existing backend instance
       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)")
+        @backend = options[:backend] ||
+          begin
+            raise ArgumentError, 'Option :file is required' unless options[:file]
+            ::SQLite3::Database.new(options[:file])
+          end
+        @backend.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}"),
-           @create = @db.prepare("insert into #{table} values (?, ?)")]
+          [@select = @backend.prepare("select v from #{table} where k = ?"),
+           @replace = @backend.prepare("replace into #{table} values (?, ?)"),
+           @delete = @backend.prepare("delete from #{table} where k = ?"),
+           @clear = @backend.prepare("delete from #{table}"),
+           @create = @backend.prepare("insert into #{table} values (?, ?)")]
       end
 
       # (see Proxy#key?)
@@ -52,7 +57,7 @@ module Moneta
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
-        @db.transaction(:exclusive) { return super }
+        @backend.transaction(:exclusive) { return super }
       end
 
       # (see Proxy#clear)
@@ -75,7 +80,7 @@ module Moneta
       # (see Proxy#close)
       def close
         @stmts.each {|s| s.close }
-        @db.close
+        @backend.close
         nil
       end
     end

data/lib/moneta/adapters/tdb.rb

@@ -7,14 +7,18 @@ module Moneta
     class TDB < Memory
       # @param [Hash] options
       # @option options [String] :file Database file
-      def initialize(options = {})
-        raise ArgumentError, 'Option :file is required' unless file = options.delete(:file)
-        @hash = ::TDB.new(file, options)
+      # @option options [::TDB] :backend Use existing backend instance
+      def initialize(options)
+        @backend = options[:backend] ||
+          begin
+            raise ArgumentError, 'Option :file is required' unless file = options.delete(:file)
+            ::TDB.new(file, options)
+          end
       end
 
       # (see Proxy#close)
       def close
-        @hash.close
+        @backend.close
         nil
       end
     end

data/lib/moneta/adapters/tokyocabinet.rb

@@ -8,34 +8,39 @@ module Moneta
       # @param [Hash] options
       # @option options [String] :file Database file
       # @option options [Symbol] :type (:hdb) Database type (:bdb and :hdb possible)
+      # @option options [::TokyoCabinet::*DB] :backend Use existing backend instance
       def initialize(options = {})
-        raise ArgumentError, 'Option :file is required' unless options[:file]
-        if options[:type] == :bdb
-          @hash = ::TokyoCabinet::BDB.new
-          @hash.open(options[:file], ::TokyoCabinet::BDB::OWRITER | ::TokyoCabinet::BDB::OCREAT)
+        if options[:backend]
+          @backend = options[:backend]
         else
-          @hash = ::TokyoCabinet::HDB.new
-          @hash.open(options[:file], ::TokyoCabinet::HDB::OWRITER | ::TokyoCabinet::HDB::OCREAT)
-        end or raise @hash.errmsg(@hash.ecode)
+          raise ArgumentError, 'Option :file is required' unless options[:file]
+          if options[:type] == :bdb
+            @backend = ::TokyoCabinet::BDB.new
+            @backend.open(options[:file], ::TokyoCabinet::BDB::OWRITER | ::TokyoCabinet::BDB::OCREAT)
+          else
+            @backend = ::TokyoCabinet::HDB.new
+            @backend.open(options[:file], ::TokyoCabinet::HDB::OWRITER | ::TokyoCabinet::HDB::OCREAT)
+          end or raise @backend.errmsg(@backend.ecode)
+        end
       end
 
       # (see Proxy#delete)
       def delete(key, options = {})
         value = load(key, options)
         if value
-          @hash.delete(key)
+          @backend.delete(key)
           value
         end
       end
 
       # (see Proxy#create)
       def create(key, value, options = {})
-        @hash.putkeep(key, value)
+        @backend.putkeep(key, value)
       end
 
       # (see Proxy#close)
       def close
-        @hash.close
+        @backend.close
         nil
       end
     end

data/lib/moneta/adapters/tokyotyrant.rb

@@ -0,0 +1,107 @@
+require 'tokyotyrant'
+
+module Moneta
+  module Adapters
+    # TokyoTyrant backend
+    # @api public
+    class TokyoTyrant
+      include Defaults
+
+      supports :create, :increment
+      attr_reader :backend
+
+      # @param [Hash] options
+      # @option options [String] :host ('127.0.0.1') Server host name
+      # @option options [Integer] :port (1978) Server port
+      # @option options [::TokyoTyrant::RDB] :backend Use existing backend instance
+      def initialize(options = {})
+        if options[:backend]
+          @backend = options[:backend]
+        else
+          @backend = ::TokyoTyrant::RDB.new
+          @backend.open(options[:host] || '127.0.0.1',
+                        options[:port] || 1978) or raise @backend.errmsg(@backend.ecode)
+        end
+        probe = '__tokyotyrant_endianness_probe'
+        @backend.delete(probe)
+        @backend.addint(probe, 1)
+        @pack = @backend.delete(probe) == [1].pack('l>') ? 'l>' : 'l<'
+      end
+
+      # (see Proxy#key?)
+      def key?(key, options = {})
+        @backend.has_key?(key)
+      end
+
+      # (see Proxy#load)
+      def load(key, options = {})
+        value = @backend[key]
+        value && unpack(value)
+      end
+
+      # (see Proxy#store)
+      def store(key, value, options = {})
+        @backend[key] = pack(value)
+        value
+      end
+
+      # (see Proxy#delete)
+      def delete(key, options = {})
+        value = load(key, options)
+        if value
+          @backend.delete(key)
+          value
+        end
+      end
+
+      # (see Proxy#increment)
+      def increment(key, amount = 1, options = {})
+        @backend.addint(key, amount) || raise('Tried to increment non integer value')
+      end
+
+      # (see Proxy#create)
+      def create(key, value, options = {})
+        @backend.putkeep(key, pack(value))
+      end
+
+      # (see Proxy#clear)
+      def clear(options = {})
+        @backend.clear
+        self
+      end
+
+      # (see Proxy#close)
+      def close
+        @backend.close
+        nil
+      end
+
+      private
+
+      def pack(value)
+        intvalue = value.to_i
+        if intvalue >= 0 && intvalue <= 0xFFFFFFFF && intvalue.to_s == value
+          # Pack as 4 byte integer
+          [intvalue].pack(@pack)
+        elsif value.bytesize >= 4
+          # Add nul character to make value distinguishable from integer
+          value + "\0"
+        else
+          value
+        end
+      end
+
+      def unpack(value)
+        if value.bytesize == 4
+          # Unpack 4 byte integer
+          value.unpack(@pack).first.to_s
+        elsif value.bytesize >= 5 && value[-1] == ?\0
+          # Remove nul character
+          value[0..-2]
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/moneta/cache.rb

@@ -1,10 +1,10 @@
 module Moneta
-  # Combines two stores. One is used as cache, the other as backend.
+  # Combines two stores. One is used as cache, the other as backend adapter.
   #
   # @example Add `Moneta::Cache` to proxy stack
   #   Moneta.build do
   #     use(:Cache) do
-  #      backend { adapter :File, :dir => 'data' }
+  #      adapter { adapter :File, :dir => 'data' }
   #      cache { adapter :Memory }
   #     end
   #   end
@@ -21,10 +21,10 @@ module Moneta
       end
 
       # @api public
-      def backend(store = nil, &block)
-        raise 'Backend already set' if @store.backend
+      def adapter(store = nil, &block)
+        raise 'Adapter already set' if @store.adapter
         raise ArgumentError, 'Only argument or block allowed' if store && block
-        @store.backend = store || Moneta.build(&block)
+        @store.adapter = store || Moneta.build(&block)
       end
 
       # @api public
@@ -35,27 +35,27 @@ module Moneta
       end
     end
 
-    attr_accessor :cache, :backend
+    attr_accessor :cache, :adapter
 
     # @param [Hash] options Options hash
     # @option options [Moneta store] :cache Moneta store used as cache
-    # @option options [Moneta store] :backend Moneta store used as backend
+    # @option options [Moneta store] :adapter Moneta store used as adapter
     # @yieldparam Builder block
     def initialize(options = {}, &block)
-      @cache, @backend = options[:cache], options[:backend]
+      @cache, @adapter = options[:cache], options[:adapter]
       DSL.new(self, &block) if block_given?
     end
 
     # (see Proxy#key?)
     def key?(key, options = {})
-      @cache.key?(key, options) || @backend.key?(key, options)
+      @cache.key?(key, options) || @adapter.key?(key, options)
     end
 
     # (see Proxy#load)
     def load(key, options = {})
       value = @cache.load(key, options)
       if value == nil
-        value = @backend.load(key, options)
+        value = @adapter.load(key, options)
         @cache.store(key, value, options) if value != nil
       end
       value
@@ -64,18 +64,18 @@ module Moneta
     # (see Proxy#store)
     def store(key, value, options = {})
       @cache.store(key, value, options)
-      @backend.store(key, value, options)
+      @adapter.store(key, value, options)
     end
 
     # (see Proxy#increment)
     def increment(key, amount = 1, options = {})
       @cache.delete(key, options)
-      @backend.increment(key, amount, options)
+      @adapter.increment(key, amount, options)
     end
 
     # (see Proxy#create)
     def create(key, value, options = {})
-      if @backend.create(key, value, options)
+      if @adapter.create(key, value, options)
         @cache.store(key, value, options)
         true
       else
@@ -86,25 +86,25 @@ module Moneta
     # (see Proxy#delete)
     def delete(key, options = {})
       @cache.delete(key, options)
-      @backend.delete(key, options)
+      @adapter.delete(key, options)
     end
 
     # (see Proxy#clear)
     def clear(options = {})
       @cache.clear(options)
-      @backend.clear(options)
+      @adapter.clear(options)
       self
     end
 
     # (see Proxy#close)
     def close
       @cache.close
-      @backend.close
+      @adapter.close
     end
 
     # (see Proxy#features)
     def features
-      @features ||= ((@cache.features + [:create, :increment]) & @backend.features).freeze
+      @features ||= ((@cache.features + [:create, :increment]) & @adapter.features).freeze
     end
   end
 end