ssdb 0.1.0

data/.gitignore

@@ -0,0 +1,3 @@
+*.gem
+.yardoc/
+doc/

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/Gemfile.lock

@@ -0,0 +1,31 @@
+PATH
+  remote: .
+  specs:
+    ssdb (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.3)
+    rake (10.0.4)
+    redcarpet (2.2.2)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.1)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.13.1)
+    yard (0.8.6.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  rake
+  redcarpet
+  rspec
+  ssdb!
+  yard

data/README.md

@@ -0,0 +1,117 @@
+# ssdb-rb
+
+A Ruby client library for [SSDB][ssdb-home], heaviliy inspired by the great
+[redis-rb][redisrb-home] library. Requires SSDB version 1.4.2 or higher.
+
+[ssdb-home]: https://github.com/ideawu/ssdb
+[redisrb-home]: https://github.com/redis/redis-rb
+
+### Installation
+
+Install via rubygems:
+
+```ruby
+gem install ssdb
+```
+
+Use it with bundler, by adding the following line to your Gemfile:
+
+```ruby
+gem "ssdb"
+```
+
+For more information please visit http://gembundler.com/.
+
+### Basic usage
+
+Connect to SSDB, assuming it is listening on `localhost`, port 8888.
+
+```ruby
+require "ssdb"
+
+ssdb = SSDB.new
+```
+
+To connect to a custom server, please provide a custom `:url` option:
+
+```ruby
+ssdb = SSDB.new url: "ssdb://1.2.3.4:8889"
+```
+
+To execute commands:
+
+```ruby
+ssdb.set("mykey", "hello world")
+# => true
+
+ssdb.get("mykey")
+# => "hello world"
+```
+
+Full documentation of all commands is available on [rdoc.info][rdoc].
+
+[rdoc]: http://rdoc.info/github/bsm/ssdb-rb/
+
+### Batching/pipelining
+
+Multiple commands can be executed as a batch operations. Instead of sending
+commands one-by-one the client is able to send a batch of commands and
+retrieve all responses as a single socket message exchange cycle.
+
+Example:
+
+```ruby
+ssdb.batch do
+  ssdb.set "foo", "5"
+  ssdb.get "foo"
+  ssdb.incr "foo"
+end
+# => [true, "5", 6]
+```
+
+### Futures
+
+Results of individual batch operations are stored as *futures*. Future values
+can be retrieved via the `#value` method once the batch execution is complete.
+
+```ruby
+ssdb.batch do
+  v = ssdb.set "foo", "bar"
+  w = ssdc.incr "baz"
+end
+
+v.value
+# => true
+
+w.value
+# => 1
+```
+
+### TODO
+
+* Implement HASH operations
+
+### Licence (MIT)
+
+```
+Copyright (c) 2013 Black Square Media Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+```

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/setup'
+require 'rspec/core/rake_task'
+require 'yard'
+
+RSpec::Core::RakeTask.new(:spec)
+
+YARD::Rake::YardocTask.new
+
+desc 'Default: run specs.'
+task :default => :spec

data/lib/ssdb.rb

@@ -0,0 +1,431 @@
+require "monitor"
+
+class SSDB
+  include MonitorMixin
+
+  Error           = Class.new(RuntimeError)
+  ConnectionError = Class.new(Error)
+  TimeoutError    = Class.new(Error)
+  CommandError    = Class.new(Error)
+  FutureNotReady  = Class.new(Error)
+
+  T_BOOL   = ->r { r == "1" }
+  T_INT    = ->r { r.to_i }
+  T_CINT   = ->r { r.to_i if r }
+  T_VBOOL  = ->r { r.each_slice(2).map {|_, v| v == "1" }}
+  T_VINT   = ->r { r.each_slice(2).map {|_, v| v.to_i }}
+  T_STRSTR = ->r { r.each_slice(2).to_a }
+  T_STRINT = ->r { r.each_slice(2).map {|v, s| [v, s.to_i] } }
+  T_MAPINT = ->r,n { h = {}; r.each_slice(2) {|k, v| h[k] = v }; n.map {|k| h[k].to_i } }
+  T_MAPSTR = ->r,n { h = {}; r.each_slice(2) {|k, v| h[k] = v }; n.map {|k| h[k] } }
+  BLANK    = "".freeze
+
+  # @attr_reader [SSDB::Client] the client
+  attr_reader :client
+
+  # @return [SSDB] the current/global SSDB connection
+  def self.current
+    @current ||= SSDB.new
+  end
+
+  # @param [SSDB] ssdb the current/global SSDB connection
+  def self.current=(ssdb)
+    @current = ssdb
+  end
+
+  # @see SSDB::Client#initialize
+  def initialize(*a)
+    @client = Client.new(*a)
+    super() # Monitor#initialize
+  end
+
+  # Execute a batch operation
+  #
+  # @example simple batch
+  #
+  #   ssdb.batch do
+  #     ssdb.set "foo", "5"
+  #     ssdb.get "foo"
+  #     ssdb.incr "foo"
+  #   end
+  #   # => [true, "5", 6]
+  #
+  # @example batch with futures
+  #
+  #   ssdb.batch do
+  #     v = ssdb.set "foo", "5"
+  #     w = ssdb.incr "foo"
+  #   end
+  #
+  #   v.value
+  #   # => true
+  #   w.value
+  #   # => 6
+  #
+  def batch
+    mon_synchronize do
+      begin
+        original, @client = @client, SSDB::Batch.new
+        yield(self)
+        @client.values = original.perform(@client)
+      ensure
+        @client = original
+      end
+    end
+  end
+
+  # Returns value at `key`.
+  #
+  # @param [String] key the key
+  # @return [String] the value
+  def get(key)
+    mon_synchronize do
+      perform ["get", key]
+    end
+  end
+
+  # Sets `value` at `key`.
+  #
+  # @param [String] key the key
+  # @param [String] value the value
+  def set(key, value)
+    mon_synchronize do
+      perform ["set", key, value], proc: T_BOOL
+    end
+  end
+
+  # Increments a `key` by value
+  #
+  # @param [String] key the key
+  # @param [Integer] value the increment
+  def incr(key, value = 1)
+    mon_synchronize do
+      perform ["incr", key, value], proc: T_INT
+    end
+  end
+
+  # Decrements a `key` by value
+  #
+  # @param [String] key the key
+  # @param [Integer] value the decrement
+  def decr(key, value = 1)
+    mon_synchronize do
+      perform ["decr", key, value], proc: T_INT
+    end
+  end
+
+  # Checks existence of `key`.
+  #
+  # @param [String] key the key
+  # @return [Boolean] true if exists
+  def exists(key)
+    mon_synchronize do
+      perform ["exists", key], proc: T_BOOL
+    end
+  end
+  alias_method :exists?, :exists
+
+  # Delete `key`.
+  #
+  # @param [String] key the key
+  def del(key)
+    mon_synchronize do
+      perform ["del", key]
+    end
+  end
+
+  # Scans keys between `start` and `stop`.
+  #
+  # @param [String] start start at this key
+  # @param [String] stop stop at this key
+  # @param [Hash] opts options
+  # @option opts [Integer] :limit limit results
+  # @return [Array<String>] matching keys
+  def keys(start, stop, opts = {})
+    limit = opts[:limit] || -1
+    mon_synchronize do
+      perform ["keys", start, stop, limit], multi: true
+    end
+  end
+
+  # Scans keys between `start` and `stop`.
+  #
+  # @param [String] start start at this key
+  # @param [String] stop stop at this key
+  # @param [Hash] opts options
+  # @option opts [Integer] :limit limit results
+  # @return [Array<Array<String,String>>] key/value pairs
+  def scan(start, stop, opts = {})
+    limit = opts[:limit] || -1
+    mon_synchronize do
+      perform ["scan", start, stop, limit], multi: true, proc: T_STRSTR
+    end
+  end
+
+  # Reverse-scans keys between `start` and `stop`.
+  #
+  # @param [String] start start at this key
+  # @param [String] stop stop at this key
+  # @param [Hash] opts options
+  # @option opts [Integer] :limit limit results
+  # @return [Array<Array<String,String>>] key/value pairs in reverse order
+  def rscan(start, stop, opts = {})
+    limit = opts[:limit] || -1
+    mon_synchronize do
+      perform ["rscan", start, stop, limit], multi: true, proc: T_STRSTR
+    end
+  end
+
+  # Sets multiple keys
+  #
+  # @param [Hash] pairs key/value pairs
+  def multi_set(pairs)
+    mon_synchronize do
+      perform ["multi_set", *pairs.to_a].flatten, proc: T_INT
+    end
+  end
+
+  # Retrieves multiple keys
+  #
+  # @param [Array<String>] keys
+  # @return [Array<String>] values
+  def multi_get(keys)
+    keys = Array(keys) unless keys.is_a?(Array)
+    mon_synchronize do
+      perform ["multi_get", *keys], multi: true, proc: T_MAPSTR, args: [keys]
+    end
+  end
+
+  # Deletes multiple keys
+  #
+  # @param [Array<String>] keys
+  def multi_del(keys)
+    keys = Array(keys) unless keys.is_a?(Array)
+    mon_synchronize do
+      perform ["multi_del", *keys], proc: T_INT
+    end
+  end
+
+  # Checks existence of multiple keys
+  #
+  # @param [Array<String>] keys
+  # @return [Array<Boolean>] results
+  def multi_exists(keys)
+    keys = Array(keys) unless keys.is_a?(Array)
+    mon_synchronize do
+      perform ["multi_exists", *keys], multi: true, proc: T_VBOOL
+    end
+  end
+
+  # Returns the score of `member` at `key`.
+  #
+  # @param [String] key the key
+  # @param [String] member the member
+  # @return [Float] the score
+  def zget(key, member)
+    mon_synchronize do
+      perform ["zget", key, member], proc: T_CINT
+    end
+  end
+
+  # Sets the `score` of `member` at `key`.
+  #
+  # @param [String] key the key
+  # @param [String] member the member
+  # @param [Numeric] score the score
+  def zset(key, member, score)
+    mon_synchronize do
+      perform ["zset", key, member, score], proc: T_BOOL
+    end
+  end
+
+  # Redis 'compatibility'.
+  #
+  # @param [String] key the key
+  # @param [Numeric] score the score
+  # @param [String] member the member
+  def zadd(key, score, member)
+    zset(key, member, score)
+  end
+
+  # Increments the `member` in `key` by `score`
+  #
+  # @param [String] key the key
+  # @param [String] member the member
+  # @param [Integer] score the increment
+  def zincr(key, member, score = 1)
+    mon_synchronize do
+      perform ["zincr", key, member, score], proc: T_INT
+    end
+  end
+
+  # Decrements the `member` in `key` by `score`
+  #
+  # @param [String] key the key
+  # @param [String] member the member
+  # @param [Integer] score the decrement
+  def zdecr(key, member, score = 1)
+    mon_synchronize do
+      perform ["zdecr", key, member, score], proc: T_INT
+    end
+  end
+
+  # Checks existence of a zset at `key`.
+  #
+  # @param [String] key the key
+  # @return [Boolean] true if exists
+  def zexists(key)
+    mon_synchronize do
+      perform ["zexists", key], proc: T_BOOL
+    end
+  end
+  alias_method :zexists?, :zexists
+
+  # Returns the cardinality of a set `key`.
+  #
+  # @param [String] key the key
+  def zsize(key)
+    mon_synchronize do
+      perform ["zsize", key], proc: T_INT
+    end
+  end
+
+  # Delete an `member` from a zset `key`.
+  #
+  # @param [String] key the key
+  # @param [String] member the member
+  def zdel(key, member)
+    mon_synchronize do
+      perform ["zdel", key, member], proc: T_BOOL
+    end
+  end
+
+  # List zset keys between `start` and `stop`.
+  #
+  # @param [String] start start at this key
+  # @param [String] stop stop at this key
+  # @param [Hash] opts options
+  # @option opts [Integer] :limit limit results
+  # @return [Array<String>] matching zset keys
+  def zlist(start, stop, opts = {})
+    limit = opts[:limit] || -1
+    mon_synchronize do
+      perform ["zlist", start, stop, limit], multi: true
+    end
+  end
+
+  # Lists members at `key` starting at `start_member`
+  # between `start` and `stop` scores.
+  #
+  # @param [String] key the zset
+  # @param [Float] start start at this score
+  # @param [Float] stop stop at this score
+  # @param [Hash] opts options
+  # @option opts [Integer] :limit limit results
+  # @return [Array<String>] matching members
+  def zkeys(key, start, stop, opts = {})
+    limit = opts[:limit] || -1
+    mon_synchronize do
+      perform ["zkeys", key, BLANK, start, stop, limit], multi: true
+    end
+  end
+
+  # Scans for members at `key` starting at `start_member`
+  # between `start` and `stop` scores.
+  #
+  # @param [String] key the zset
+  # @param [Float] start start at this score
+  # @param [Float] stop stop at this score
+  # @param [Hash] opts options
+  # @option opts [Integer] :limit limit results
+  # @return [Array<Array<String,Float>>] member/score pairs
+  def zscan(key, start, stop, opts = {})
+    limit = opts[:limit] || -1
+    mon_synchronize do
+      perform ["zscan", key, BLANK, start, stop, limit], multi: true, proc: T_STRINT
+    end
+  end
+
+  # Reverse scans for members at `key` starting at `start_member`
+  # between `start` and `stop` scores.
+  #
+  # @param [String] key the zset
+  # @param [Float] start start at this score
+  # @param [Float] stop stop at this score
+  # @param [Hash] opts options
+  # @option opts [Integer] :limit limit results
+  # @return [Array<Array<String,Float>>] member/score pairs
+  def zrscan(key, start, stop, opts = {})
+    limit = opts[:limit] || -1
+    mon_synchronize do
+      perform ["zrscan", key, BLANK, start, stop, limit], multi: true, proc: T_STRINT
+    end
+  end
+
+  # Checks existence of multiple sets
+  #
+  # @param [Array<String>] keys
+  # @return [Array<Boolean>] results
+  def multi_zexists(keys)
+    keys = Array(keys) unless keys.is_a?(Array)
+    mon_synchronize do
+      perform ["multi_zexists", *keys], multi: true, proc: T_VBOOL
+    end
+  end
+
+  # Returns cardinalities of multiple sets
+  #
+  # @param [Array<String>] keys
+  # @return [Array<Boolean>] results
+  def multi_zsize(keys)
+    keys = Array(keys) unless keys.is_a?(Array)
+    mon_synchronize do
+      perform ["multi_zsize", *keys], multi: true, proc: T_VINT
+    end
+  end
+
+  # Sets multiple members of `key`
+  #
+  # @param [String] key the zset
+  # @param [Hash] pairs key/value pairs
+  def multi_zset(key, pairs)
+    mon_synchronize do
+      perform ["multi_zset", key, *pairs.to_a].flatten, proc: T_INT
+    end
+  end
+
+  # Retrieves multiple scores from `key`
+  #
+  # @param [String] key the zset
+  # @param [Array<String>] members
+  # @return [Array<Float>] scores
+  def multi_zget(key, members)
+    members = Array(members) unless members.is_a?(Array)
+    mon_synchronize do
+      perform ["multi_zget", key, *members], multi: true, proc: T_MAPINT, args: [members]
+    end
+  end
+
+  # Deletes multiple members from `key`
+  #
+  # @param [String] key the zset
+  # @param [Array<String>] members
+  def multi_zdel(key, members)
+    members = Array(members) unless members.is_a?(Array)
+    mon_synchronize do
+      perform ["multi_zdel", key, *members], proc: T_INT
+    end
+  end
+
+  private
+
+    def perform(chain, opts = {})
+      opts[:cmd] = chain.map(&:to_s)
+      client.call(opts)
+    end
+
+end
+
+%w|version client batch future|.each do |name|
+  require "ssdb/#{name}"
+end