Release 0.6.0

Author: ngan

Gemfile.lock

@@ -1,8 +1,9 @@
 PATH
   remote: .
   specs:
-    bigrails-redis (0.5.0)
+    bigrails-redis (0.6.0)
       rails (>= 6)
+      redis (>= 4)
 
 GEM
   remote: https://rubygems.org/

README.md

@@ -18,9 +18,15 @@ Create a redis configuration file:
 
 The configuration file (`config/redis.rb`) is just a plain Ruby file that will be evaluated when a connection is requested. Use the `connection` DSL method to declare your connections. The method will yield a block and you're expected to return a configuration hash.
 
-A configuration hash, by default, is passed to `ActiveSupport::Cache::RedisCacheStore.build_redis(...)`. This is a Rails supplied helper which allows for more options than demostrated above. You'll want to [check out its source](https://github.com/rails/rails/blob/main/activesupport/lib/active_support/cache/redis_cache_store.rb#L77-L100) to get a better idea of what it supports.
+The configuration hash is passed to the default `Builder`. You can customize the builder with your own object/proc that responds to `#call`.
 
 ```ruby
+# Change the default builder.
+Rails.application.redis.builder = ->(options) {
+  # options is the hash returned from the connection block.
+  Redis.new(...)
+}
+
 # Simple hardcoded example.
 connection(:default) do
   {

bigrails-redis.gemspec

@@ -22,4 +22,5 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
 
   spec.add_dependency "rails", ">= 6"
+  spec.add_dependency "redis", ">= 4"
 end

lib/big_rails/redis.rb

@@ -8,8 +8,9 @@ module Redis
     extend ActiveSupport::Autoload
 
     autoload :ApplicationExtension
-    autoload :ConfigurationDsl
+    autoload :Builder
     autoload :Configuration
+    autoload :ConfigurationDsl
     autoload :Registry
   end
 end

lib/big_rails/redis/builder.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "redis"
+
+module BigRails
+  module Redis
+    class Builder
+      class << self
+        def call(options)
+          config = Configuration.new(options)
+
+          if config.pool_options.any?
+            ensure_connection_pool_added!
+
+            ::ConnectionPool.new(config.pool_options) { build(config) }
+          else
+            build(config)
+          end
+        end
+
+        private
+
+        def build(config)
+          if config.urls.size > 1
+            build_redis_distributed_client(urls: config.urls, **config.redis_options)
+          else
+            build_redis_client(url: config.urls.first, **config.redis_options)
+          end
+        end
+
+        def build_redis_distributed_client(urls:, **redis_options)
+          ::Redis::Distributed.new([], redis_options).tap do |dist|
+            urls.each { |u| dist.add_node(url: u) }
+          end
+        end
+
+        def build_redis_client(url:, **redis_options)
+          ::Redis.new(redis_options.merge(url: url))
+        end
+
+        def ensure_connection_pool_added!
+          require "connection_pool"
+        rescue LoadError => e
+          warn "You don't have connection_pool installed in your application. Please add it to your Gemfile and run bundle install"
+          raise
+        end
+      end
+    end
+  end
+end

lib/big_rails/redis/configuration.rb

@@ -5,24 +5,15 @@ module Redis
     class Configuration
       attr_reader :redis_options
       attr_reader :pool_options
+      attr_reader :urls
 
       def initialize(redis_options)
         @redis_options = redis_options
+        @urls = Array(redis_options.delete(:url))
         @pool_options ||= {}.tap do |pool_options|
           pool_options[:size] = redis_options.delete(:pool_size) if redis_options[:pool_size]
           pool_options[:timeout] = redis_options.delete(:pool_timeout) if redis_options[:pool_timeout]
         end
-
-        ensure_connection_pool_added! if pool_options.any?
-      end
-
-      private
-
-      def ensure_connection_pool_added!
-        require "connection_pool"
-      rescue LoadError => e
-        warn "You don't have connection_pool installed in your application. Please add it to your Gemfile and run bundle install"
-        raise e
       end
     end
   end

lib/big_rails/redis/configuration_dsl.rb

@@ -28,7 +28,7 @@ def connection(name)
           raise ArgumentError, "connection named '#{name}' already registered"
         end
 
-        @__configurations[name.to_s] = Configuration.new(yield)
+        @__configurations[name.to_s] = yield
       end
     end
   end

lib/big_rails/redis/registry.rb

@@ -5,7 +5,6 @@ module Redis
     class Registry
       class UnknownConnection < StandardError
       end
-
       class VerificationError < StandardError
       end
 
@@ -14,11 +13,7 @@ class VerificationError < StandardError
       def initialize
         @connections = {}
         @wrapped_connections = {}
-
-        # Default redis builder.
-        @builder = ->(config) {
-          ActiveSupport::Cache::RedisCacheStore.build_redis(**config.redis_options)
-        }
+        @builder = Builder
       end
 
       def for(name, wrapped: false)
@@ -71,12 +66,7 @@ def verify!(*names)
 
       def build_connection(name)
         config = configurations.fetch(name)
-
-        if config.pool_options.any?
-          ::ConnectionPool.new(config.pool_options) { builder.call(config) }
-        else
-          builder.call(config)
-        end
+        builder.call(config)
       end
 
       def build_wrapped_connection(connection)

lib/big_rails/redis/version.rb

@@ -2,6 +2,6 @@
 
 module BigRails
   module Redis
-    VERSION = "0.5.0"
+    VERSION = "0.6.0"
   end
 end

spec/big_rails/redis/registry_spec.rb

@@ -43,27 +43,24 @@
 
   describe "#config_for" do
     it "returns config for specific connection" do
-      expect(instance.config_for("default").redis_options).to eq(
+      expect(instance.config_for("default")).to eq(
         url: "redis://localhost"
       )
 
-      expect(instance.config_for("pooled").redis_options).to eq(
-        url: "redis://localhost/2"
-      )
-
-      expect(instance.config_for("pooled").pool_options).to eq(
-        timeout: 5,
-        size: 5
+      expect(instance.config_for("pooled")).to eq(
+        url: "redis://localhost/2",
+        pool_timeout: 5,
+        pool_size: 5
       )
     end
   end
 
   describe "#each" do
     it "iterates through all connections" do
       instance.each do |conn|
-        if conn.is_a? ::Redis
+        if conn.is_a?(::Redis)
           expect(conn).to eq(instance.for("default"))
-        elsif conn.is_a? ::ConnectionPool
+        elsif conn.is_a?(::ConnectionPool)
           expect(conn).to eq(instance.for("pooled"))
         end
       end