refactor: avoid rescuing pattern repetition

lib/rack/attack/store_proxy/dalli_proxy.rb

@@ -24,35 +24,35 @@ module Rack
         end
 
         def read(key)
-          with do |client|
+          rescuing do
-            client.get(key)
+            with do |client|
+              client.get(key)
+            end
           end
-        rescue Dalli::DalliError
-          nil
         end
 
         def write(key, value, options = {})
-          with do |client|
+          rescuing do
-            client.set(key, value, options.fetch(:expires_in, 0), raw: true)
+            with do |client|
+              client.set(key, value, options.fetch(:expires_in, 0), raw: true)
+            end
           end
-        rescue Dalli::DalliError
-          nil
         end
 
         def increment(key, amount, options = {})
-          with do |client|
+          rescuing do
-            client.incr(key, amount, options.fetch(:expires_in, 0), amount)
+            with do |client|
+              client.incr(key, amount, options.fetch(:expires_in, 0), amount)
+            end
           end
-        rescue Dalli::DalliError
-          nil
         end
 
         def delete(key)
-          with do |client|
+          rescuing do
-            client.delete(key)
+            with do |client|
+              client.delete(key)
+            end
           end
-        rescue Dalli::DalliError
-          nil
         end
 
         private
@@ -64,6 +64,12 @@ module Rack
             end
           end
         end
+
+        def rescuing
+          yield
+        rescue Dalli::DalliError
+          nil
+        end
       end
     end
   end

lib/rack/attack/store_proxy/redis_proxy.rb

@@ -19,36 +19,38 @@ module Rack
         end
 
         def read(key)
-          get(key)
+          rescuing { get(key) }
-        rescue Redis::BaseError
-          nil
         end
 
         def write(key, value, options = {})
           if (expires_in = options[:expires_in])
-            setex(key, expires_in, value)
+            rescuing { setex(key, expires_in, value) }
           else
-            set(key, value)
+            rescuing { set(key, value) }
           end
-        rescue Redis::BaseError
-          nil
         end
 
         def increment(key, amount, options = {})
           count = nil
 
-          pipelined do
+          rescuing do
-            count = incrby(key, amount)
+            pipelined do
-            expire(key, options[:expires_in]) if options[:expires_in]
+              count = incrby(key, amount)
+              expire(key, options[:expires_in]) if options[:expires_in]
+            end
           end
 
           count.value if count
-        rescue Redis::BaseError
-          nil
         end
 
         def delete(key, _options = {})
-          del(key)
+          rescuing { del(key) }
+        end
+
+        private
+
+        def rescuing
+          yield
         rescue Redis::BaseError
           nil
         end

lib/rack/attack/store_proxy/redis_store_proxy.rb

@@ -11,19 +11,15 @@ module Rack
         end
 
         def read(key)
-          get(key, raw: true)
+          rescuing { get(key, raw: true) }
-        rescue Redis::BaseError
-          nil
         end
 
         def write(key, value, options = {})
           if (expires_in = options[:expires_in])
-            setex(key, expires_in, value, raw: true)
+            rescuing { setex(key, expires_in, value, raw: true) }
           else
-            set(key, value, raw: true)
+            rescuing { set(key, value, raw: true) }
           end
-        rescue Redis::BaseError
-          nil
         end
       end
     end