hella-redis 0.2.0 → 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2c11849c706992fadaf24788eab0d8e5998350e08b429646c772097fc32cd048
+  data.tar.gz: c291e238be0cff2321ea88058c3c3eb22496702595b6f6900e9a80570901865e
+SHA512:
+  metadata.gz: 7f8ea4a862606da3b802ff7a841320dfe05ca6cea1304aa05b089b022d7711f4bc2779c9032b4cc231a731e9b6e9b4c3ab096c7dab35cdd6c3b731f0c65bcbb8
+  data.tar.gz: fe824c06209a19cea1e0b72ac261bf788e9b6d044803acd3003e5216be0ea1429fd2c1e37fd5a34227831d32f0d822668729483710477333ae053e3a38aaf022

data/.l.yml

@@ -0,0 +1,9 @@
+# https://github.com/redding/l.rb
+
+linters:
+  - name: "Rubocop"
+    cmd: "bundle exec rubocop"
+    autocorrect_cmd: "bundle exec rubocop -A"
+    extensions:
+      - ".rb"
+    cli_abbrev: "u"

data/.rubocop.yml

@@ -0,0 +1,3 @@
+inherit_gem:
+  much-style-guide:
+    - "lib/much-style-guide/rubocop.yml"

data/.ruby-version

@@ -0,0 +1 @@
+2.7.3

data/.t.yml

@@ -0,0 +1,6 @@
+# https://github.com/redding/t.rb
+
+default_cmd: "bundle exec assert"
+test_dir: "test"
+test_file_suffixes:
+  - "_tests.rb"

data/Gemfile

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
+ruby "~> 2.5"
+
 gemspec
 
-gem 'rake'
-gem 'pry', "~> 0.9.0"
+gem "pry"

data/README.md

@@ -2,32 +2,72 @@
 
 It's-a hella-redis!
 
-## Usage
+This gem is a wrapper that builds a connection pool of redis connections.  It also provides spies and test mode behavior to ease testing redis interactions.
 
-### Connection
+## Usage
 
 ```ruby
-# config and create a connection
-@config = {
-  :timeout  => 1,
-  :size     => 5,
-  :redis_ns => 'hella-redis-test',
-  :driver   => 'ruby',
-  :url      => 'redis://localhost:6379/0'
-}
-@conn = HellaRedis::Connection.new(@config)
+# create
+@redis =
+  HellaRedis.new(
+    timeout:  1,
+    size:     5,
+    redis_ns: "hella-redis-test",
+    driver:   "ruby",
+    url:      "redis://localhost:6379/0"
+  ) # => HellaRedis:ConnectionPool instance
 
 # it's actually a pool of connections
-@conn.with do |conn|
-  # get a connection and do something with it
+@redis.connection do |connection|
+  # checks out a connection so you can do something with it
+  # will check it back in once the block has run
+end
+```
+
+### Test Mode
+
+```ruby
+ENV["HELLA_REDIS_TEST_MODE"] = "yes" # set to anything "truthy"
+
+@redis_spy =
+  HellaRedis.new({
+    timeout:  1,
+    size:     5,
+    redis_ns: "hella-redis-test",
+    driver:   "ruby",
+    url:      "redis://localhost:6379/0"
+  }) # => HellaRedis::ConnectionPoolSpy instance
+
+@redis_spy.connection do |connection|
+  connection # => HellaRedis::ConnectionSpy instance
+  connection.info
+end
+
+@redis_spy.calls.size # => 1
+@redis_spy.calls.first.tap do |call|
+  call.command # => :info
+  call.args    # => nil
+  call.block   # => nil
+end
+
+@redis_spy.connection_calls.size # => 1
+@redis_spy.connection_calls.first.tap do |connection_call|
+  connection_call.block # => block instance
+end
+
+Assert.stub(@redis_spy.connection_spy, :get).with("some-key"){ "some-value" }
+value = @redis_spy.connection do |connection|
+  connection.get("some_key")
 end
+assert_that("some-value").equals(value)
+@redis_spy.calls.size # => 1 (unchanged b/c we stubbed the :get method)
 ```
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
-    gem 'hella-redis'
+    gem "hella-redis"
 
 And then execute:
 

data/hella-redis.gemspec

@@ -1,5 +1,7 @@
 # -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "hella-redis/version"
 
@@ -8,19 +10,22 @@ Gem::Specification.new do |gem|
   gem.version     = HellaRedis::VERSION
   gem.authors     = ["Kelly Redding", "Collin Redding"]
   gem.email       = ["kelly@kellyredding.com", "collin.redding@me.com"]
-  gem.description = %q{It's-a hella-redis!}
-  gem.summary     = %q{It's-a hella-redis!}
+  gem.summary     = "It's-a hella-redis!"
+  gem.description = "It's-a hella-redis!"
   gem.homepage    = "http://github.com/redding/hella-redis"
+  gem.license     = "MIT"
 
-  gem.files         = `git ls-files`.split($/)
+  gem.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_development_dependency("assert")
+  gem.required_ruby_version = "~> 2.5"
 
-  gem.add_dependency("redis",           ["~> 3.2"])
-  gem.add_dependency("redis-namespace", ["~> 1.5"])
-  gem.add_dependency("connection_pool", ["=  0.9.2"]) # temp, for 1.8.7 support
+  gem.add_development_dependency("assert", ["~> 2.19.6"])
+  gem.add_development_dependency("much-style-guide", ["~> 0.6.3"])
 
+  gem.add_dependency("redis",           ["~> 4.2.5"])
+  gem.add_dependency("redis-namespace", ["~> 1.8.1"])
+  gem.add_dependency("connection_pool", ["~> 2.2.5"])
 end

data/lib/hella-redis.rb

@@ -1,5 +1,44 @@
-require 'hella-redis/version'
-require 'hella-redis/connection'
+# frozen_string_literal: true
+
+require "hella-redis/version"
+require "hella-redis/connection_pool"
+require "hella-redis/connection_pool_spy"
 
 module HellaRedis
+  def self.new(args)
+    send(ENV["HELLA_REDIS_TEST_MODE"] ? :mock : :real, args)
+  end
+
+  def self.real(args)
+    ConnectionPool.new(Config.new(args))
+  end
+
+  def self.mock(args)
+    ConnectionPoolSpy.new(Config.new(args))
+  end
+
+  class Config
+    attr_reader :url, :driver, :redis_ns, :timeout, :size
+
+    def initialize(args = nil)
+      args ||= {}
+      @url      = args[:url]
+      @driver   = args[:driver]
+      @redis_ns = args[:redis_ns]
+      @timeout  = args[:timeout]
+      @size     = args[:size] || 1
+    end
+
+    def ==(other)
+      if other.is_a?(Config)
+        url      == other.url      &&
+        driver   == other.driver   &&
+        redis_ns == other.redis_ns &&
+        timeout  == other.timeout  &&
+        size     == other.size
+      else
+        super
+      end
+    end
+  end
 end

data/lib/hella-redis/connection_pool.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "connection_pool"
+require "redis"
+require "redis-namespace"
+
+module HellaRedis
+  class ConnectionPool
+    def initialize(config)
+      @pool =
+        ::ConnectionPool.new(
+          timeout: config.timeout,
+          size: config.size,
+        ) do
+          ::Redis::Namespace.new(
+            config.redis_ns,
+            redis: ::Redis.new(url: config.url, driver: config.driver),
+          )
+        end
+    end
+
+    def connection
+      @pool.with do |connection|
+        yield connection if block_given?
+      end
+    end
+  end
+end

data/lib/hella-redis/connection_pool_spy.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "redis"
+require "hella-redis/connection_pool"
+require "hella-redis/connection_spy"
+
+module HellaRedis
+  class ConnectionPoolSpy
+    attr_reader :config, :connection_spy, :connection_calls
+
+    def initialize(config)
+      @config           = config
+      @connection_spy   = ConnectionSpy.new(config)
+      @connection_calls = []
+    end
+
+    def calls
+      @connection_spy.calls
+    end
+
+    def connection(&block)
+      @connection_calls << ConnectionCall.new(block)
+      block.call(@connection_spy)
+    end
+
+    def reset!
+      @connection_calls     = []
+      @connection_spy.calls = []
+    end
+
+    def ==(other)
+      config == other.config if other.is_a?(ConnectionPoolSpy)
+    end
+
+    ConnectionCall = Struct.new(:block)
+  end
+end

data/lib/hella-redis/connection_spy.rb

@@ -1,58 +1,42 @@
-require 'redis'
-require 'hella-redis/connection'
+# frozen_string_literal: true
 
-module HellaRedis
+require "redis"
 
+module HellaRedis
   class ConnectionSpy
+    attr_accessor :calls
 
-    attr_reader :config, :redis_spy, :with_calls
-
-    def initialize(config, redis_spy = nil)
-      @config     = config
-      @with_calls = []
-      @redis_spy  = redis_spy || RedisSpy.new(config)
+    def initialize(config)
+      @instance =
+        ::Redis.new(
+          url: config.url,
+          driver: config.driver,
+        )
+      @calls = []
     end
 
-    def with(*args, &block)
-      @with_calls << WithCall.new(args, block)
-      block.call(@redis_spy)
+    def pipelined
+      @calls << ConnectionCall.new(:pipelined, [])
+      yield self
     end
 
-    def redis_calls
-      @redis_spy.calls
-    end
-
-  end
-
-  class RedisSpy
-
-    attr_reader :calls
-
-    def initialize(config)
-      # mimic the real conection behavior, accept hash or object
-      config = Connection::Config.new(config) if config.kind_of?(::Hash)
-      @instance = ::Redis.new({
-        :url    => config.url,
-        :driver => config.driver
-      })
-      @calls = []
+    def multi
+      @calls << ConnectionCall.new(:multi, [])
+      yield self
     end
 
     def method_missing(name, *args, &block)
-      if self.respond_to?(name)
-        @calls << RedisCall.new(name, args, block)
+      if respond_to?(name)
+        @calls << ConnectionCall.new(name, args, block)
       else
         super
       end
     end
 
-    def respond_to?(*args)
+    def respond_to_missing?(*args)
       super || @instance.respond_to?(*args)
     end
 
+    ConnectionCall = Struct.new(:command, :args, :block)
   end
-
-  WithCall  = Struct.new(:args, :block)
-  RedisCall = Struct.new(:command, :args, :block)
-
 end

data/lib/hella-redis/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module HellaRedis
-  VERSION = "0.2.0"
+  VERSION = "0.5.0"
 end

data/test/helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # this file is automatically required when you run `assert`
 # put any test helpers here
 
@@ -5,6 +7,6 @@
 $LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
 
 # require pry for debugging (`binding.pry`)
-require 'pry'
+require "pry"
 
-require 'test/support/factory'
+require "test/support/factory"

data/test/support/factory.rb

@@ -1,6 +1,21 @@
-require 'assert/factory'
+# frozen_string_literal: true
+
+require "assert/factory"
+require "hella-redis"
 
 module Factory
   extend Assert::Factory
 
+  def self.config(args = nil)
+    HellaRedis::Config.new(config_args(args))
+  end
+
+  def self.config_args(args = nil)
+    { timeout: Factory.integer,
+      size: Factory.integer(5),
+      redis_ns: "hella-redis-test-#{Factory.string}",
+      url: "redis://localhost:6379/0",
+      driver: "ruby",
+    }.merge(args || {})
+  end
 end

data/test/unit/connection_pool_spy_tests.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "assert"
+require "hella-redis/connection_pool_spy"
+
+require "hella-redis/connection_spy"
+
+class HellaRedis::ConnectionPoolSpy
+  class UnitTests < Assert::Context
+    desc "HellaRedis::ConnectionPoolSpy"
+    setup do
+      Assert.stub_tap_on_call(HellaRedis::ConnectionSpy, :new) do |_, call|
+        @connection_spy_new_call = call
+      end
+
+      @config              = Factory.config
+      @connection_pool_spy = HellaRedis::ConnectionPoolSpy.new(@config)
+    end
+    subject{ @connection_pool_spy }
+
+    should have_readers :config, :connection_spy, :connection_calls
+    should have_imeths :calls, :connection, :reset!
+
+    should "know its config and redis spy" do
+      assert_that(subject.config).is(@config)
+      assert_that(subject.connection_spy)
+        .is_an_instance_of(HellaRedis::ConnectionSpy)
+      assert_that(@connection_spy_new_call.args).equals([@config])
+    end
+
+    should "default its connection calls" do
+      assert_that(subject.connection_calls).equals([])
+    end
+
+    should "know its calls" do
+      assert_that(subject.calls).is(subject.connection_spy.calls)
+    end
+
+    should "yield its connection spy using `connection`" do
+      yielded = nil
+      subject.connection{ |c| yielded = c }
+
+      assert_that(yielded).is(subject.connection_spy)
+    end
+
+    should "track calls to connection" do
+      block = proc{ |_c| Factory.string }
+      subject.connection(&block)
+
+      call = subject.connection_calls.last
+      assert_that(call.block).is(block)
+    end
+
+    should "remove all calls on `reset!`" do
+      subject.connection(&:info)
+
+      assert_that(subject.calls.empty?).is_false
+      assert_that(subject.connection_calls.empty?).is_false
+
+      subject.reset!
+
+      assert_that(subject.calls.empty?).is_true
+      assert_that(subject.connection_calls.empty?).is_true
+    end
+
+    should "know if it is equal to another pool spy" do
+      equal_pool_spy = HellaRedis::ConnectionPoolSpy.new(@config)
+      assert_that(equal_pool_spy).equals(subject)
+
+      not_equal_config = HellaRedis::ConnectionPoolSpy.new(Factory.config)
+      assert_that(not_equal_config).does_not_equal(subject)
+    end
+  end
+end

data/test/unit/connection_pool_tests.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "assert"
+require "hella-redis/connection_pool"
+
+require "redis-namespace"
+
+class HellaRedis::ConnectionPool
+  class UnitTests < Assert::Context
+    desc "HellaRedis::Connection"
+    setup do
+      @connection_pool = HellaRedis::ConnectionPool.new(Factory.config)
+    end
+    subject{ @connection_pool }
+
+    should have_imeths :connection
+
+    should "build a redis namespace and yield it using `connection`" do
+      subject.connection do |connection|
+        assert_that(connection).is_an_instance_of(::Redis::Namespace)
+        assert_that{ connection.get(Factory.string) }.does_not_raise
+      end
+    end
+  end
+end

data/test/unit/connection_spy_tests.rb

@@ -1,100 +1,49 @@
-require 'assert'
-require 'hella-redis/connection_spy'
+# frozen_string_literal: true
 
-class HellaRedis::ConnectionSpy
+require "assert"
+require "hella-redis/connection_spy"
 
+class HellaRedis::ConnectionSpy
   class UnitTests < Assert::Context
-    setup do
-      @config = {
-        :url    => 'redis://localhost:6379/0',
-        :driver => 'ruby'
-      }
-    end
-
-  end
-
-  class ConnectionSpyTests < UnitTests
     desc "HellaRedis::ConnectionSpy"
     setup do
-      @connection_spy = HellaRedis::ConnectionSpy.new(@config)
+      @connection_spy = HellaRedis::ConnectionSpy.new(Factory.config)
     end
     subject{ @connection_spy }
 
-    should have_readers :config, :redis_spy, :with_calls
-    should have_imeths :with, :redis_calls
-
-    should "know its config and redis spy" do
-      assert_equal @config, subject.config
-      assert_instance_of HellaRedis::RedisSpy, subject.redis_spy
-    end
-
-    should "default its with calls" do
-      assert_equal [], subject.with_calls
-    end
-
-    should "know its redis spy's calls" do
-      assert_same subject.redis_spy.calls, subject.redis_calls
-    end
-
-    should "yield its redis spy using `with`" do
-      yielded = nil
-      subject.with{ |c| yielded = c }
-      assert_same subject.redis_spy, yielded
-    end
-
-    should "track calls to with" do
-      overrides = { :timeout => Factory.integer }
-      block = proc{ |c| Factory.string }
-      subject.with(overrides, &block)
-      call = subject.with_calls.last
-      assert_equal [overrides], call.args
-      assert_equal block, call.block
-    end
-
-    should "allow passing a custom redis spy" do
-      redis_spy = Factory.string
-      spy = HellaRedis::ConnectionSpy.new(@config, redis_spy)
-      assert_equal redis_spy, spy.redis_spy
-    end
-
-  end
-
-  class RedisSpyTests < UnitTests
-    desc "HellaRedis::RedisSpy"
-    setup do
-      @redis_spy = HellaRedis::RedisSpy.new(@config)
-    end
-    subject{ @redis_spy }
-
-    should have_readers :calls
+    should have_accessors :calls
+    should have_imeths :pipelined, :multi
 
     should "default its calls" do
-      assert_equal [], subject.calls
-    end
-
-    should "allow passing a config object" do
-      config = OpenStruct.new(@config)
-      assert_nothing_raised{ HellaRedis::RedisSpy.new(config) }
+      assert_that(subject.calls).equals([])
     end
 
     should "track redis calls made to it" do
-      assert_true subject.respond_to?(:set)
+      assert_that(subject.respond_to?(:set)).is_true
 
       key, value = [Factory.string, Factory.string]
       subject.set(key, value)
 
       call = subject.calls.first
-      assert_equal :set, call.command
-      assert_equal [key, value], call.args
+      assert_that(call.command).equals(:set)
+      assert_that(call.args).equals([key, value])
+    end
+
+    should "track the call and yield itself using `pipelined`" do
+      subject.pipelined{ |c| c.set(Factory.string, Factory.string) }
+      assert_that(subject.calls.map(&:command)).equals([:pipelined, :set])
+    end
+
+    should "track the call and yield itself using `multi`" do
+      subject.multi{ |c| c.set(Factory.string, Factory.string) }
+      assert_that(subject.calls.map(&:command)).equals([:multi, :set])
     end
 
     should "raise no method errors for non-redis methods" do
-      assert_false subject.respond_to?(:super_awesome_set)
-      assert_raises(NoMethodError) do
+      assert_that(subject.respond_to?(:super_awesome_set)).is_false
+      assert_that{
         subject.super_awesome_set(Factory.string, Factory.string)
-      end
+      }.raises(NoMethodError)
     end
-
   end
-
 end

data/test/unit/hella-redis_tests.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "assert"
+require "hella-redis"
+
+module HellaRedis
+  class UnitTests < Assert::Context
+    desc "HellaRedis"
+    setup do
+      @config_args = Factory.config_args
+      @module      = HellaRedis
+    end
+    subject{ @module }
+
+    should have_imeths :new, :real, :mock
+  end
+
+  class NewRealMockTests < UnitTests
+    setup do
+      @config = Config.new(@config_args)
+
+      @pool = ConnectionPool.new(@config)
+      @pool_new_called_with = nil
+      Assert.stub_on_call(ConnectionPool, :new) do |call|
+        @pool_new_call = call
+        @pool
+      end
+
+      @pool_spy = ConnectionPoolSpy.new(@config)
+      @pool_spy_new_called_with = nil
+      Assert.stub_on_call(ConnectionPoolSpy, :new) do |call|
+        @pool_spy_new_call = call
+        @pool_spy
+      end
+    end
+  end
+
+  class NewTests < NewRealMockTests
+    desc "`new`"
+    setup do
+      @current_test_mode = ENV["HELLA_REDIS_TEST_MODE"]
+      ENV["HELLA_REDIS_TEST_MODE"] = "yes"
+    end
+    teardown do
+      ENV["HELLA_REDIS_TEST_MODE"] = @current_test_mode
+    end
+
+    should "build and return a new connection pool" do
+      ENV.delete("HELLA_REDIS_TEST_MODE")
+      redis = subject.new(@config_args)
+
+      assert_that(@pool_new_call.args).equals([@config])
+      assert_that(redis).equals(@pool)
+    end
+
+    should "build and return a connection pool spy in test mode" do
+      redis = subject.new(@config_args)
+
+      assert_that(@pool_spy_new_call.args).equals([@config])
+      assert_that(redis).equals(@pool_spy)
+    end
+  end
+
+  class RealTests < NewRealMockTests
+    desc "`real`"
+
+    should "build and return a connection pool spy" do
+      redis = subject.real(@config_args)
+
+      assert_that(@pool_new_call.args).equals([@config])
+      assert_that(redis).equals(@pool)
+    end
+  end
+
+  class MockTests < NewRealMockTests
+    desc "`mock`"
+
+    should "build and return a connection pool spy" do
+      redis = subject.mock(@config_args)
+
+      assert_that(@pool_spy_new_call.args).equals([@config])
+      assert_that(redis).equals(@pool_spy)
+    end
+  end
+
+  class ConfigTests < UnitTests
+    desc "Config"
+    setup do
+      @config = Config.new(@config_args)
+    end
+    subject{ @config }
+
+    should have_readers :url, :driver, :redis_ns, :timeout, :size
+
+    should "know its attributes" do
+      assert_that(subject.url).equals(@config_args[:url])
+      assert_that(subject.driver).equals(@config_args[:driver])
+      assert_that(subject.redis_ns).equals(@config_args[:redis_ns])
+      assert_that(subject.timeout).equals(@config_args[:timeout])
+      assert_that(subject.size).equals(@config_args[:size])
+    end
+
+    should "default its size" do
+      @config_args.delete(:size)
+      config = Config.new(@config_args)
+      assert_that(config.size).equals(1)
+    end
+
+    should "know if it is equal to another config" do
+      equal_config = Config.new(@config_args)
+      assert_that(subject).equals(equal_config)
+
+      not_equal_config = Config.new
+      assert_that(subject).does_not_equal(not_equal_config)
+    end
+  end
+end

metadata

@@ -1,145 +1,143 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: hella-redis
-version: !ruby/object:Gem::Version 
-  hash: 23
-  prerelease: 
-  segments: 
-  - 0
-  - 2
-  - 0
-  version: 0.2.0
+version: !ruby/object:Gem::Version
+  version: 0.5.0
 platform: ruby
-authors: 
+authors:
 - Kelly Redding
 - Collin Redding
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2014-12-30 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  version_requirements: *id001
-  type: :development
+date: 2021-05-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: assert
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.19.6
+  type: :development
   prerelease: false
-- !ruby/object:Gem::Dependency 
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 3
-        - 2
-        version: "3.2"
-  version_requirements: *id002
-  type: :runtime
-  name: redis
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.19.6
+- !ruby/object:Gem::Dependency
+  name: much-style-guide
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+  type: :development
   prerelease: false
-- !ruby/object:Gem::Dependency 
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 5
-        segments: 
-        - 1
-        - 5
-        version: "1.5"
-  version_requirements: *id003
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.5
   type: :runtime
-  name: redis-namespace
   prerelease: false
-- !ruby/object:Gem::Dependency 
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - "="
-      - !ruby/object:Gem::Version 
-        hash: 63
-        segments: 
-        - 0
-        - 9
-        - 2
-        version: 0.9.2
-  version_requirements: *id004
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.5
+- !ruby/object:Gem::Dependency
+  name: redis-namespace
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.1
   type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+- !ruby/object:Gem::Dependency
   name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.5
+  type: :runtime
   prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.5
 description: It's-a hella-redis!
-email: 
+email:
 - kelly@kellyredding.com
 - collin.redding@me.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- .gitignore
+files:
+- ".gitignore"
+- ".l.yml"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".t.yml"
 - Gemfile
-- LICENSE.txt
+- LICENSE
 - README.md
-- Rakefile
 - hella-redis.gemspec
 - lib/hella-redis.rb
-- lib/hella-redis/connection.rb
+- lib/hella-redis/connection_pool.rb
+- lib/hella-redis/connection_pool_spy.rb
 - lib/hella-redis/connection_spy.rb
 - lib/hella-redis/version.rb
-- log/.gitkeep
+- log/.keep
 - test/helper.rb
 - test/support/factory.rb
+- test/unit/connection_pool_spy_tests.rb
+- test/unit/connection_pool_tests.rb
 - test/unit/connection_spy_tests.rb
-- test/unit/connection_tests.rb
-- tmp/.gitkeep
+- test/unit/hella-redis_tests.rb
+- tmp/.keep
 homepage: http://github.com/redding/hella-redis
-licenses: []
-
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: 
-rubygems_version: 1.8.29
+rubygems_version: 3.1.6
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: It's-a hella-redis!
-test_files: 
+test_files:
 - test/helper.rb
 - test/support/factory.rb
+- test/unit/connection_pool_spy_tests.rb
+- test/unit/connection_pool_tests.rb
 - test/unit/connection_spy_tests.rb
-- test/unit/connection_tests.rb
+- test/unit/hella-redis_tests.rb

data/Rakefile

@@ -1 +0,0 @@
-require "bundler/gem_tasks"

data/lib/hella-redis/connection.rb

@@ -1,35 +0,0 @@
-require 'connection_pool'
-require 'redis'
-require 'redis-namespace'
-
-module HellaRedis
-
-  module Connection
-
-    def self.new(config)
-      config = Config.new(config) if config.kind_of?(::Hash)
-      ::ConnectionPool.new(:timeout => config.timeout, :size => config.size) do
-        ::Redis::Namespace.new(config.redis_ns, {
-          :redis => ::Redis.new({
-            :url    => config.url,
-            :driver => config.driver
-          })
-        })
-      end
-    end
-
-    class Config
-      attr_reader :url, :driver, :redis_ns, :timeout, :size
-
-      def initialize(args)
-        @url      = args[:url]
-        @driver   = args[:driver]
-        @redis_ns = args[:ns]
-        @timeout  = args[:timeout]
-        @size     = args[:size] || 1
-      end
-    end
-
-  end
-
-end

data/test/unit/connection_tests.rb

@@ -1,75 +0,0 @@
-require 'assert'
-require 'hella-redis/connection'
-
-require 'connection_pool'
-require 'ostruct'
-
-module HellaRedis::Connection
-
-  class UnitTests < Assert::Context
-    desc "HellaRedis::Connection"
-    setup do
-      @config_hash = {
-        :timeout  => 1,
-        :size     => 5,
-        :redis_ns => 'hella-redis-test',
-        :driver   => 'ruby',
-        :url      => 'redis://localhost:6379/0'
-      }
-      @conn = HellaRedis::Connection.new(@config_hash)
-    end
-    subject{ @conn }
-
-    should "build a connection pool" do
-      assert_instance_of ::ConnectionPool, subject
-    end
-
-    should "connect to the redis instance that was provided" do
-      assert_nothing_raised do
-        subject.with{ |c| c.info }
-      end
-    end
-
-    should "build a redis namespace and yield it using `with`" do
-      subject.with do |conn|
-        assert_instance_of ::Redis::Namespace, conn
-      end
-    end
-
-    should "allow passing a config object when building a connection" do
-      conn = nil
-      assert_nothing_raised do
-        config = OpenStruct.new(@config_hash)
-        conn = HellaRedis::Connection.new(config)
-      end
-      assert_instance_of ::ConnectionPool, conn
-    end
-
-  end
-
-  class ConfigTests < UnitTests
-    desc "Config"
-    setup do
-      @config = Config.new(@config_hash)
-    end
-    subject{ @config }
-
-    should have_readers :url, :driver, :redis_ns, :timeout, :size
-
-    should "know its attributes" do
-      assert_equal @config_hash[:url],     subject.url
-      assert_equal @config_hash[:driver],  subject.driver
-      assert_equal @config_hash[:ns],      subject.redis_ns
-      assert_equal @config_hash[:timeout], subject.timeout
-      assert_equal @config_hash[:size],    subject.size
-    end
-
-    should "default its size" do
-      @config_hash.delete(:size)
-      config = Config.new(@config_hash)
-      assert_equal 1, config.size
-    end
-
-  end
-
-end