redic-rb 1.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1e6a500c5ac8d333481dcc65b4c7f9eb9dddc322f80fdc691d73aa0d426fadee
+  data.tar.gz: '09da31f87e4089f3100256ad018ec6f0e687c9ed0e46c316b8e404831c3045d4'
+SHA512:
+  metadata.gz: a080ef7608225c3587c66f4f6115af50710686218b26e2a95dff8cb67d6baba9a3f8f8566c30872a41a6d014a04afd003650f21f4ef7920c4231e4f78df07e75
+  data.tar.gz: 894767f8f0a73c5440ef5dffc237ce4190b92237eb485803d8de9acbb682de65ee04dccd03046abeec6b2bcb3d40e701425d9bcc697f16a0a9ce7bff7bf1404e

data/.gems

@@ -0,0 +1,2 @@
+cutest -v 1.2.3
+hiredis -v 0.6.3

data/.gitignore

@@ -0,0 +1 @@
+/.gs

data/CHANGELOG

@@ -0,0 +1,35 @@
+1.5.1
+
+- Allow timeout to be changed.
+
+1.5.0
+
+- Raise runtime errors when using `call!`.
+
+1.4.1
+
+- Reconnect only if URLs differ.
+
+1.4.0
+
+- Close connections with Redic#quit.
+
+1.3.0
+
+- Improve support for multithreaded environments.
+
+1.2.0
+
+- Add Redic#configure.
+
+1.1.1
+
+- Redic can now connect to sentinels.
+
+1.1.0
+
+- Redic is now compatible with all rubies.
+
+1.0.0
+
+- Add a configurable timeout.

data/CONTRIBUTING

@@ -0,0 +1,19 @@
+This code tries to solve a particular problem with a very simple
+implementation. We try to keep the code to a minimum while making
+it as clear as possible. The design is very likely finished, and
+if some feature is missing it is possible that it was left out on
+purpose. That said, new usage patterns may arise, and when that
+happens we are ready to adapt if necessary.
+
+A good first step for contributing is to meet us on IRC and discuss
+ideas. We spend a lot of time on #lesscode at freenode, always ready
+to talk about code and simplicity. If connecting to IRC is not an
+option, you can create an issue explaining the proposed change and
+a use case. We pay a lot of attention to use cases, because our
+goal is to keep the code base simple. Usually the result of a
+conversation is the creation of a different tool.
+
+Please don't start the conversation with a pull request. The code
+should come at last, and even though it may help to convey an idea,
+more often than not it draws the attention to a particular
+implementation.

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+ gemspec

data/Gemfile.lock

@@ -0,0 +1,59 @@
+PATH
+  remote: .
+  specs:
+    redic-rb (1.6)
+      redis (~> 4.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    awesome_print (1.8.0)
+    byebug (11.0.0)
+    clap (1.0.0)
+    coderay (1.1.2)
+    coolline (0.5.0)
+      unicode_utils (~> 1.4)
+    cutest (1.2.3)
+      clap
+    hirb (0.7.3)
+    hirb-unicode-steakknife (0.0.8)
+      hirb (~> 0.5)
+      unicode-display_width (~> 1.1)
+    method_source (0.9.2)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    pry-byebug (3.7.0)
+      byebug (~> 11.0)
+      pry (~> 0.10)
+    pry-coolline (0.2.5)
+      coolline (~> 0.5)
+    pry-doc (0.13.5)
+      pry (~> 0.11)
+      yard (~> 0.9.11)
+    pry-rails (0.3.9)
+      pry (>= 0.10.4)
+    redis (4.1.0)
+    spirit_hands (2.1.5)
+      awesome_print (~> 1.6)
+      hirb (~> 0.7)
+      hirb-unicode-steakknife (~> 0.0)
+      pry (~> 0.10)
+      pry-byebug (~> 3.4)
+      pry-coolline (~> 0.2)
+      pry-doc (~> 0.8)
+      pry-rails (~> 0.3)
+    unicode-display_width (1.5.0)
+    unicode_utils (1.4.0)
+    yard (0.9.18)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  cutest (~> 1.2)
+  redic-rb!
+  spirit_hands (~> 2.1)
+
+BUNDLED WITH
+   1.16.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2013-2014 Michel Martens, Cyril David
+
+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/README.md

@@ -0,0 +1,142 @@
+Redic
+=====
+
+Lightweight Redis Client
+
+Description
+-----------
+
+Lightweight Redis Client inspired by [redigo][redigo], a Redis
+client library for golang.
+
+## Usage
+
+```ruby
+# Accepts a Redis URL and defaults to "redis://127.0.0.1:6379".
+redis = Redic.new
+
+# Processes the command and returns the response.
+redis.call("SET", "foo", "bar")
+
+assert_equal "bar", redis.call("GET", "foo")
+
+# Pipelining is implemented by buffering commands,
+# then calling Redic#commit
+redis.queue("SET", "foo", "bar")
+redis.queue("GET", "foo")
+
+assert_equal ["OK", "bar"], redis.commit
+```
+
+You can provide the password and the database to be selected. The
+format for Redis URLs is `redis://user:pass@host:port/db`. As
+Redis only needs a password for authentication, the user can be
+omitted:
+
+```ruby
+# Connect to localhost:6380 using "bar" as password and use the
+# database 2. Both AUTH and SELECT commands are issued after
+# connecting. The user part of the URL is not provided.
+redis = Redic.new("redis://:bar@localhost:6380/2")
+```
+
+It is also possible to configure a timeout for the connection. The
+default timeout is 10 seconds.
+
+```ruby
+# Timeout expressed in microseconds.
+redis = Redic.new(REDIS_URL, 2_000_000)
+redis.timeout == 2_000_000 #=> true
+```
+A client can be re-configured, forcing the next connection to
+be established with the new details:
+
+```ruby
+redis = Redic.new("redis://localhost:6379")
+redis.configure("redis://localhost:6380")
+```
+
+Here's one final example using both a Redis URL and a timeout:
+
+```ruby
+# It's recommended to store the REDIS_URL as an environment
+# variable. Use `fetch` to retrieve values that must be present,
+# as it raises an error if the value is not found.
+REDIS_URL = ENV.fetch("REDIS_URL")
+REDIS_TIMEOUT = ENV.fetch("REDIS_TIMEOUT")
+
+redis = Redic.new(REDIS_URL, REDIS_TIMEOUT)
+```
+
+Both the initializer and the `configure` method accept a `URL` and
+a `timeout`.
+
+In order to close the connection, call `quit`:
+
+```ruby
+redis = Redic.new("redis://localhost:6379")
+redis.quit
+```
+
+With that command, `"QUIT"` is sent to Redis and the socket is closed.
+
+## Differences with redis-rb
+
+Redic uses [hiredis][hiredis] for the connection and for parsing
+the replies. There are no alternative connection drivers. Unlike
+[redis-rb][redis-rb] it doesn't define all the Redis commands, and
+instead it acts as a transport layer. The lock provided is smaller
+than that of redis-rb, as it only wraps the writing and reading from
+the connection. So even if both clients are thread-safe by default,
+the peformance of a smaller lock is marginally better.
+
+[redigo]: https://github.com/garyburd/redigo
+[hiredis]: https://github.com/pietern/hiredis-rb
+[redis-rb]: https://github.com/redis/redis-rb
+
+## Limitations
+
+When a client enters a subscribed mode, further reads to retrieve the
+messages are not thread safe. It is very important to take this into
+account and to create a different client if you need to send different
+operations while a client is subscribed to a channel.
+
+```ruby
+# Example of pub/sub usage.
+c1 = Redic.new
+c2 = Redic.new
+
+# After this command, the client is no longer thread safe.
+c1.call("SUBSCRIBE", "foo")
+
+# That's why we need to publish from a different connection.
+c2.call("PUBLISH", "foo")
+
+# Note that this operation is not thread safe.
+assert_equal ["message", "foo", "value1"], c1.client.read
+```
+
+You can wrap thread unsafe operations in a mutex:
+
+```ruby
+redis = Redic.new
+
+mutex = Mutex.new
+
+mutex.synchronize do
+  redis.call("MONITOR")
+
+  # Display every command sent to Redis.
+  loop do
+    puts redis.client.read
+  end
+end
+```
+
+## Installation
+
+You can install it using rubygems.
+
+```
+$ gem install redic
+```

data/bin/console

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "redic"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+ require "pry"
+ Pry.start
+

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/redic/client.rb

@@ -0,0 +1,116 @@
+require_relative "connection"
+require "uri"
+require "redis"
+
+class Redic
+  class Client
+    EMPTY = "".freeze
+    SLASH = "/".freeze
+
+    attr_accessor :timeout
+
+    def initialize(url, timeout)
+      @semaphore = Mutex.new
+      @connection = false
+
+      configure(url, timeout)
+    end
+
+    def configure(url, timeout)
+      disconnect!
+
+      @uri = URI.parse(url)
+      @timeout = timeout
+    end
+
+    def read
+      #@connection.read
+      @response
+    end
+
+    def write(command)
+      #@connection.write(command)
+      cmd_name = command.shift.to_s.downcase
+      block = command.find{ |cmd| cmd.is_a? Proc }
+      #binding.pry if cmd_name == "subscribe"
+      @response = if command.empty?
+        @connection.send(cmd_name)
+      else
+        @connection.send(cmd_name, *command, &block)
+      end
+    rescue => e
+      return raise e if e.message =~ /ERR invalid DB index/
+      return raise e if e.message =~  /ERR invalid password/
+      @response = RuntimeError.new(e.message)
+    end
+
+    def connect
+      establish_connection unless connected?
+
+      @semaphore.synchronize do
+        yield
+      end
+    rescue Errno::ECONNRESET
+      @connection = false
+      retry
+    end
+
+    def connected?
+      @connection && @connection.connected?
+    end
+
+    def disconnect!
+      if connected?
+        @connection.disconnect!
+        @connection = false
+      end
+    end
+
+    def quit
+      if connected?
+        assert_ok(call("QUIT"))
+        disconnect!
+
+        true
+      else
+        false
+      end
+    end
+
+  private
+    def establish_connection
+      begin
+        #Redic::Connection.new(@uri, @timeout)
+        @connection = Redis.new(url: @uri)
+        raise StandardError if @connection.ping != "PONG"
+      rescue StandardError => err
+        raise err, "Can't connect to: #{@uri} because: #{err.message}"
+      end
+
+      if @uri.scheme != "unix"
+        if @uri.password
+          assert_ok(call("AUTH", @uri.password))
+        end
+
+        if @uri.path != EMPTY && @uri.path != SLASH
+          assert_ok(call("SELECT", @uri.path[1..-1]))
+        end
+      end
+    end
+
+    def call(*args)
+      @semaphore.synchronize do
+        write(args)
+        read
+      end
+    end
+
+    def assert(value, error)
+      raise error unless value
+    end
+
+    def assert_ok(reply)
+      assert(reply == "OK", reply)
+    end
+  end
+end

data/lib/redic/connection.rb

@@ -0,0 +1,17 @@
+#require "hiredis/connection"
+#
+#class Redic
+#  module Connection
+#    def self.new(uri, timeout)
+#      connection = Hiredis::Connection.new
+#
+#      if uri.scheme == "unix"
+#        connection.connect_unix(uri.path, timeout)
+#      else
+#        connection.connect(uri.host, uri.port, timeout)
+#      end
+#
+#      connection
+#    end
+#  end
+#end

data/lib/redic.rb

@@ -0,0 +1,75 @@
+require 'redis'
+require_relative "redic/client"
+
+class Redic
+  attr :url
+  attr :client
+
+  def initialize(url = "redis://127.0.0.1:6379", timeout = 10_000_000)
+    @url = url
+    @client = Redic::Client.new(url, timeout)
+    @buffer = Hash.new { |h, k| h[k] = [] }
+  end
+
+  def buffer
+    @buffer[Thread.current.object_id]
+  end
+
+  def reset
+    @buffer.delete(Thread.current.object_id)
+  end
+
+  def clear
+    @buffer.clear
+  end
+
+  def configure(url, timeout = 10_000_000)
+    if @url != url
+      @url = url
+      @client.configure(url, timeout)
+    end
+  end
+
+  def call(*args)
+    @client.connect do
+      @client.write(args)
+      @client.read
+    end
+  end
+
+  def call!(*args)
+    reply = call(*args)
+
+    if RuntimeError === reply
+      raise reply
+    end
+
+    return reply
+  end
+
+  def queue(*args)
+    buffer << args
+  end
+
+  def commit
+    @client.connect do
+      buffer.map do |args|
+        @client.write(args)
+      end
+    end
+  ensure
+    reset
+  end
+
+  def timeout
+    @client.timeout
+  end
+
+  def timeout=(timeout)
+    @client.timeout = timeout
+  end
+
+  def quit
+    @client.quit
+  end
+end

data/makefile

@@ -0,0 +1,2 @@
+test:
+	RUBYLIB=./lib cutest tests/*.rb

data/redic-rb.gemspec

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+Gem::Specification.new do |s|
+  s.name              = "redic-rb"
+  s.version           = "1.6"
+  s.summary           = "Lightweight Redis Client"
+  s.description       = "Lightweight Redis Client"
+  s.authors           = ["Michel Martens", "Cyril David", "Diego Gomez"]
+  s.email             = ["michel@soveran.com", "cyx@cyx.is", "diego.f.gomez.pardo@gmail.com"]
+  s.homepage          = "https://github.com/degz/redic-rb"
+  s.files             = `git ls-files`.split("\n")
+  s.license           = "MIT"
+
+  s.add_dependency "redis", "~> 4.1"
+
+  s.add_development_dependency "spirit_hands", "~> 2.1"
+  s.add_development_dependency "cutest", "~> 1.2"
+
+end

data/tests/multithreaded_test.rb

@@ -0,0 +1,54 @@
+require "cutest"
+require_relative "../lib/redic"
+
+REDIS_URL = "redis://localhost:6379/"
+
+prepare do
+  c = Redic.new(REDIS_URL)
+
+  begin
+    c.call("FLUSHDB")
+  rescue
+    c.call("AUTH", "foo")
+    c.call("FLUSHDB")
+    c.call("CONFIG", "SET", "requirepass", "")
+  end
+end
+
+test "multiple threads" do
+
+  cs = Array.new
+
+  c = Redic.new(REDIS_URL)
+
+  c.queue("SET", "foo", "1")
+
+  t1 = Thread.new do
+    c.queue("SET", "bar", "2")
+  end
+
+  t2 = Thread.new do
+    c.queue("SET", "baz", "3")
+    c.commit
+  end
+
+  t1.join
+  t2.join
+
+  assert_equal nil, c.call("GET", "foo")
+  assert_equal nil, c.call("GET", "bar")
+  assert_equal "3", c.call("GET", "baz")
+
+  c.commit
+
+  # The buffer for `c` still exists
+  assert_equal "1", c.call("GET", "foo")
+
+  # Buffer for the thread that didn't commit is the only one left
+  assert_equal 1, c.instance_variable_get("@buffer").keys.size
+
+  c.clear
+
+  # All buffers are cleared
+  assert_equal 0, c.instance_variable_get("@buffer").keys.size
+end

data/tests/redic_test.rb

@@ -0,0 +1,232 @@
+require "cutest"
+require_relative "../lib/redic"
+require 'pry'
+
+REDIS_URL = "redis://localhost:6379/0"
+
+prepare do
+  c = Redic.new(REDIS_URL)
+
+  begin
+    c.call!("FLUSHDB").inspect
+  rescue
+    c.call!("AUTH", "foo")
+    c.call!("SELECT", "0")
+    c.call!("FLUSHDB")
+    c.call!("CONFIG", "SET", "requirepass", "")
+  end
+end
+
+setup do
+  Redic.new(REDIS_URL)
+end
+
+test "url" do |c|
+  assert_equal "redis://localhost:6379/0", c.url
+end
+
+test "select db from url" do |c1|
+
+  # Connect to db 1
+  c2 = Redic.new("redis://localhost:6379/2")
+
+  c2.call("FLUSHDB")
+
+  # Set a value in db 0
+  c1.call("SET", "foo", "bar")
+
+  assert_equal(1, c1.call("DBSIZE"))
+  assert_equal(0, c2.call("DBSIZE"))
+end
+
+test "error when selecting db from url" do
+  c2 = Redic.new("redis://localhost:6379/foo")
+
+  assert_raise(RuntimeError) do
+
+    # Connection is lazy, send a command
+    c2.call("PING")
+  end
+end
+
+test "error when authenticating from url" do |c1|
+
+  # Configure password as "foo"
+  c1.call("CONFIG", "SET", "requirepass", "foo")
+
+  # The password provided is wrong
+  c2 = Redic.new("redis://:bar@localhost:6379/")
+
+  assert_raise(RuntimeError) do
+
+    # Connection is lazy, send a command
+    c2.call("PING")
+  end
+
+  c3 = Redic.new("redis://:foo@localhost:6379/")
+  assert_equal "PONG", c3.call("PING")
+
+  # Remove password
+  c3.call("CONFIG", "SET", "requirepass", "")
+end
+
+#test "Can connect to sentinel" do
+#  c2 = Redic.new "redis://localhost:26379"
+#  c2.call "SENTINEL", "masters"
+#end
+
+test "timeout" do |c1|
+
+  # Default timeout is 10 seconds
+  assert_equal 10_000_000, c1.timeout
+
+  # Timeout configured to 200_000 microseconds
+  c2 = Redic.new(REDIS_URL, 200_000)
+
+  assert_equal 200_000, c2.timeout
+
+  # Change timeout to 5 seconds
+  c2.timeout = 5_000_000
+
+  assert_equal 5_000_000, c2.timeout
+end
+
+test "normal commands" do |c|
+  c.call("SET", "foo", "bar")
+
+  assert_equal "bar", c.call("GET", "foo")
+end
+
+test "pipelining" do |c|
+  c.queue("SET", "foo", "perro")
+  c.queue("GET", "foo")
+
+  assert_equal ["OK", "perro"], c.commit
+end
+
+test "multi/exec" do |c|
+  c.queue("MULTI")
+  c.queue("SET", "foo", "bar")
+  c.queue("EXEC")
+
+  assert_equal ["OK", "QUEUED", ["OK"]], c.commit
+end
+
+test "runtime errors" do |c|
+  res = c.call("KABLAMMO")
+
+  assert res.is_a?(RuntimeError)
+end
+
+test "encoding" do |c|
+  Encoding.default_external = "UTF-8"
+
+  c.call("SET", "foo", "שלום")
+
+  assert_equal "Shalom שלום", "Shalom " + c.call("GET", "foo")
+
+end if defined?(Encoding)
+
+test "errors in pipeline" do |c|
+  c.queue("SET", "foo", "bar")
+  c.queue("INCR", "foo")
+  c.queue("GET", "foo")
+
+  res = c.commit
+
+  assert "OK" == res[0]
+  assert RuntimeError === res[1]
+  assert "bar" == res[2]
+end
+
+test "thread safety" do |c|
+  c.call("SET", "foo", 1)
+  c.call("SET", "bar", 2)
+
+  foos, bars = nil, nil
+
+  t1 = Thread.new do
+    foos = Array.new(100) { c.call("GET", "foo") }
+  end
+
+  t2 = Thread.new do
+    bars = Array.new(100) { c.call("GET", "bar") }
+  end
+
+  t1.join
+  t2.join
+
+  assert_equal ["1"], foos.uniq
+  assert_equal ["2"], bars.uniq
+end
+
+test "blocking commands" do |c1|
+  c2 = Redic.new
+  r = nil
+
+  t1 = Thread.new do
+    r = c1.call("BLPOP", "foo", 5)
+  end
+
+  t2 = Thread.new do
+    c2.call("RPUSH", "foo", "value")
+  end
+
+  t1.join
+  t2.join
+
+  assert_equal ["foo", "value"], r
+end
+
+#test "pub/sub" do |c1|
+#  c2 = Redic.new
+#
+#  binding.pry
+#  res = c1.call("SUBSCRIBE", "foo", Proc.new{})
+#  assert_equal ["subscribe", "foo", 1], res
+#
+#  c2.call("PUBLISH", "foo", "value1")
+#  c2.call("PUBLISH", "foo", "value2")
+#
+#  assert_equal ["message", "foo", "value1"], c1.client.read
+#  assert_equal ["message", "foo", "value2"], c1.client.read
+#
+#  c1.call("UNSUBSCRIBE", "foo")
+#
+#  assert_equal "PONG", c1.call("PING")
+#end
+
+test "reconnect" do |c1|
+  url = "redis://:foo@localhost:6379/"
+
+  assert url != c1.url
+
+  c1.call("CONFIG", "SET", "requirepass", "foo")
+
+  c1.configure(url)
+
+  assert url == c1.url
+  assert url.object_id == c1.url.object_id
+
+  # Reconfigure only if URLs differ
+  c1.configure(url.dup)
+
+  # No reconnection ocurred
+  assert url.object_id == c1.url.object_id
+
+  assert_equal "PONG", c1.call("PING")
+end
+
+test "disconnect" do |c1|
+
+  # Connection is lazy
+  assert_equal false, c1.client.connected?
+  assert_equal false, c1.quit
+
+  c1.call("PING")
+
+  assert_equal true, c1.client.connected?
+  assert_equal true, c1.quit
+
+  assert_equal false, c1.client.connected?
+end

data/tests/unix_test.rb

@@ -0,0 +1,27 @@
+require "cutest"
+require_relative "../lib/redic"
+
+setup do
+  Redic.new("unix:///tmp/redis.6379.sock")
+end
+
+test "normal commands" do |c|
+  c.call("SET", "foo", "bar")
+
+  assert_equal "bar", c.call("GET", "foo")
+end
+
+test "pipelining" do |c|
+  c.queue("SET", "foo", "bar")
+  c.queue("GET", "foo")
+
+  assert_equal ["OK", "bar"], c.commit
+end
+
+test "multi/exec" do |c|
+  c.queue("MULTI")
+  c.queue("SET", "foo", "bar")
+  c.queue("EXEC")
+
+  assert_equal ["OK", "QUEUED", ["OK"]], c.commit
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: redic-rb
+version: !ruby/object:Gem::Version
+  version: '1.6'
+platform: ruby
+authors:
+- Michel Martens
+- Cyril David
+- Diego Gomez
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-03-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: spirit_hands
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: cutest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: Lightweight Redis Client
+email:
+- michel@soveran.com
+- cyx@cyx.is
+- diego.f.gomez.pardo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gems"
+- ".gitignore"
+- CHANGELOG
+- CONTRIBUTING
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- bin/console
+- bin/setup
+- lib/redic.rb
+- lib/redic/client.rb
+- lib/redic/connection.rb
+- makefile
+- redic-rb.gemspec
+- tests/multithreaded_test.rb
+- tests/redic_test.rb
+- tests/unix_test.rb
+homepage: https://github.com/degz/redic-rb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: Lightweight Redis Client
+test_files: []