redis-store 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 10e6007fb1a0708fe88d7627a23a2b5e8e0303e9ee81ec886d27a5c6fdb7ed07
-  data.tar.gz: 9415f933dae0284fe8114cf6d350561bc23c58bcf9f1182d734f36fdf8436707
+SHA1:
+  metadata.gz: 7d09e598db500a23547cfabf8b0ee023aa473aa5
+  data.tar.gz: 34fea83415585fe81210982d30f1f8891e4f90c5
 SHA512:
-  metadata.gz: 69a4d72561bf0b9da2c88cc7a32d37a7ca06bb758a60d338bc4c12added10c1549f818f6e0e68af3854e0911a92f591c3c3094455d731f7a48d1cb1b47a9a700
-  data.tar.gz: da5fee4e7926a6032ca82fa7ee924c0a676124bffb55c84d5f553f066eb0ca47678cad583403ccc5979d04b7ddcdeb98652edf906472db364713baf483bc64e3
+  metadata.gz: a50a647e8edc5a25a1a2d9c2038bac4bec7d77cdc4b68734004c9f5cf4aec105a6d737172cf2a4759239309484aaf9470f73a0db14f0b08bec76718d8a5bd242
+  data.tar.gz: 24c45f122e99129e14c8dc352875ed7be76c3461623f4b101f955fa2322a4eb16ed0c53c62e1da936480c6e0d096284c77fed18c816f95c64957a9e8776396ad

data/.codeclimate.yml

@@ -0,0 +1,6 @@
+---
+plugins:
+  rubocop:
+    enabled: true
+  fixme:
+    enabled: true

data/.rubocop.yml

@@ -0,0 +1,138 @@
+---
+AllCops:
+  TargetRubyVersion: 2.4
+  # RuboCop has a bunch of cops enabled by default. This setting tells RuboCop
+  # to ignore them, so only the ones explicitly set in this file are enabled.
+  DisabledByDefault: true
+  Exclude:
+    - '**/vendor/**/*'
+
+# Prefer &&/|| over and/or.
+Style/AndOr:
+  Enabled: true
+
+# Do not use braces for hash literals when they are the last argument of a
+# method call.
+Style/BracesAroundHashParameters:
+  Enabled: true
+  EnforcedStyle: context_dependent
+
+# Align comments with method definitions.
+Layout/CommentIndentation:
+  Enabled: true
+
+Layout/ElseAlignment:
+  Enabled: true
+
+Layout/EmptyLineAfterMagicComment:
+  Enabled: true
+
+# In a regular class definition, no empty lines around the body.
+Layout/EmptyLinesAroundClassBody:
+  Enabled: true
+
+# In a regular method definition, no empty lines around the body.
+Layout/EmptyLinesAroundMethodBody:
+  Enabled: true
+
+# In a regular module definition, no empty lines around the body.
+Layout/EmptyLinesAroundModuleBody:
+  Enabled: true
+
+Layout/FirstParameterIndentation:
+  Enabled: true
+
+# Method definitions after `private` or `protected` isolated calls need one
+# extra level of indentation.
+Layout/IndentationConsistency:
+  Enabled: true
+  EnforcedStyle: rails
+
+# Two spaces, no tabs (for indentation).
+Layout/IndentationWidth:
+  Enabled: true
+
+Layout/LeadingCommentSpace:
+  Enabled: true
+
+Layout/SpaceAfterColon:
+  Enabled: true
+
+Layout/SpaceAfterComma:
+  Enabled: true
+
+Layout/SpaceAroundEqualsInParameterDefault:
+  Enabled: true
+
+Layout/SpaceAroundKeyword:
+  Enabled: true
+
+Layout/SpaceAroundOperators:
+  Enabled: true
+
+Layout/SpaceBeforeComma:
+  Enabled: true
+
+Layout/SpaceBeforeFirstArg:
+  Enabled: true
+
+Style/DefWithParentheses:
+  Enabled: true
+
+# Defining a method with parameters needs parentheses.
+Style/MethodDefParentheses:
+  Enabled: true
+
+# Use `foo {}` not `foo{}`.
+Layout/SpaceBeforeBlockBraces:
+  Enabled: true
+
+# Use `foo { bar }` not `foo {bar}`.
+Layout/SpaceInsideBlockBraces:
+  Enabled: true
+
+# Use `{ a: 1 }` not `{a:1}`.
+Layout/SpaceInsideHashLiteralBraces:
+  Enabled: true
+
+Layout/SpaceInsideParens:
+  Enabled: true
+
+# Detect hard tabs, no hard tabs.
+Layout/Tab:
+  Enabled: true
+
+# Blank lines should not have any spaces.
+Layout/TrailingBlankLines:
+  Enabled: true
+
+# No trailing whitespace.
+Layout/TrailingWhitespace:
+  Enabled: true
+
+# Use quotes for string literals when they are enough.
+Style/UnneededPercentQ:
+  Enabled: true
+
+# Align `end` with the matching keyword or starting expression except for
+# assignments, where it should be aligned with the LHS.
+Layout/EndAlignment:
+  Enabled: true
+  EnforcedStyleAlignWith: variable
+  AutoCorrect: true
+
+# Use my_method(my_arg) not my_method( my_arg ) or my_method my_arg.
+Lint/RequireParentheses:
+  Enabled: true
+
+Style/RedundantReturn:
+  Enabled: true
+  AllowMultipleReturnValues: true
+
+Style/Semicolon:
+  Enabled: true
+  AllowAsExpressionSeparator: true
+
+# Prefer Foo.method over Foo::method
+Style/ColonMethodCall:
+  Enabled: true

data/.travis.yml

@@ -5,12 +5,14 @@ notifications:
   webhooks: https://www.travisbuddy.com
   on_success: never
 
-# 1.9.3 has Bundler 1.7.6 with the "undefined method `spec' for nil" bug
-before_install: gem install bundler
+before_install:
+  # Install Code Climate test reporter
+  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+  - chmod +x ./cc-test-reporter
+  # 1.9.3 has Bundler 1.7.6 with the "undefined method `spec' for nil" bug
+  - gem install bundler
 
 rvm:
-  - 1.9.3
-  - 2.0
   - 2.1
   - 2.2
   - 2.3
@@ -22,14 +24,18 @@ gemfile:
   - gemfiles/redis_3_x.gemfile
   - gemfiles/redis_4_x.gemfile
 
+before_script: ./cc-test-reporter before-build
+
+# Pipe the coverage data to Code Climate if tests pass
+after_script:
+  - ./cc-test-reporter after-build --exit-code $EXIT_CODE
+  - ./cc-test-reporter format-coverage -t simplecov -o coverage/codeclimate.json
+  - if [[ "$TRAVIS_TEST_RESULT" == 0 ]]; then ./cc-test-reporter upload-coverage; fi  # Upload coverage/codeclimate.json
+
 matrix:
   allow_failures:
     - rvm: jruby-head
     - rvm: ruby-head
   exclude:
-    - rvm: 1.9.3
-      gemfile: gemfiles/redis_4_x.gemfile
-    - rvm: 2.0
-      gemfile: gemfiles/redis_4_x.gemfile
     - rvm: 2.1
       gemfile: gemfiles/redis_4_x.gemfile

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 1.6.0
+
+Breaking Changes
+
+* None
+
+Added
+
+* [SSL/TLS Support with the rediss:// URI scheme](https://github.com/redis-store/redis-store/pull/306)
+* [Use Code Style Guide For New Contributions](https://github.com/redis-store/redis-store/pull/309)
+
+Fixed
+
+* None
+
 ## 1.5.0
 
 Breaking Changes

data/README.md

@@ -23,7 +23,7 @@ Download and install Redis from [the download page](http://redis.io//download) a
 ```ruby
 git clone git://github.com/redis-store/redis-store.git
 cd redis-store
-gem install bundler
+bundle install
 bundle exec rake
 ```
 

data/Rakefile

@@ -3,7 +3,9 @@ require 'rake'
 require 'bundler/gem_tasks'
 require 'redis-store/testing/tasks'
 require 'appraisal'
+require 'rubocop/rake_task'
 
+RuboCop::RakeTask.new :lint
 
 if !ENV["APPRAISAL_INITIALIZED"] && !ENV["TRAVIS"]
   task :default do

data/lib/redis/distributed_store.rb

@@ -5,7 +5,7 @@ class Redis
     @@timeout = 5
     attr_reader :ring
 
-    def initialize(addresses, options = { })
+    def initialize(addresses, options = {})
       _extend_namespace options
       @ring = options[:ring] || Redis::HashRing.new([], options[:replicas] || Redis::HashRing::POINTS_PER_SERVER)
 
@@ -19,7 +19,7 @@ class Redis
     end
 
     def reconnect
-      nodes.each {|node| node.reconnect }
+      nodes.each { |node| node.reconnect }
     end
 
     def set(key, value, options = nil)
@@ -57,10 +57,10 @@ class Redis
       end
 
       def _merge_options(address, options)
-        address.merge({
-          :timeout => options[:timeout] || @@timeout, 
+        address.merge(
+          :timeout => options[:timeout] || @@timeout,
           :namespace => options[:namespace]
-        })
+        )
       end
   end
 end

data/lib/redis/store.rb

@@ -13,7 +13,7 @@ class Redis
   class Store < self
     include Ttl, Interface, RedisVersion
 
-    def initialize(options = { })
+    def initialize(options = {})
       super
 
       unless options[:marshalling].nil?
@@ -66,4 +66,3 @@ class Redis
       end
   end
 end
-

data/lib/redis/store/factory.rb

@@ -3,7 +3,6 @@ require 'uri'
 class Redis
   class Store < self
     class Factory
-
       DEFAULT_PORT = 6379
 
       def self.create(*options)
@@ -41,7 +40,7 @@ class Redis
         if host_options?(options)
           options
         else
-          nil 
+          nil
         end
       end
 
@@ -57,12 +56,12 @@ class Redis
                           !options[:marshalling]
                         else
                           false
-                        end
+        end
         options
       end
 
       def self.host_options?(options)
-        options.keys.any? {|n| [:host, :db, :port, :path].include?(n) }
+        options.keys.any? { |n| [:host, :db, :port, :path].include?(n) }
       end
 
       def self.extract_host_options_from_uri(uri)
@@ -71,13 +70,14 @@ class Redis
           options = { :path => uri.path }
         else
           _, db, namespace = if uri.path
-                               uri.path.split(/\//)
-                             end
+            uri.path.split(/\//)
+          end
 
           options = {
+            :scheme   => uri.scheme,
             :host     => uri.hostname,
             :port     => uri.port || DEFAULT_PORT,
-            :password => uri.password.nil? ? nil : CGI::unescape(uri.password.to_s)
+            :password => uri.password.nil? ? nil : CGI.unescape(uri.password.to_s)
           }
 
           options[:db]        = db.to_i   if db
@@ -95,16 +95,16 @@ class Redis
 
       private
 
-      def extract_addresses_and_options(*options)
-        options.flatten.compact.each do |token| 
-          resolved = self.class.resolve(token)
-          if resolved
-            @addresses << resolved
-          else
-            @options.merge!(self.class.normalize_key_names(token))
+        def extract_addresses_and_options(*options)
+          options.flatten.compact.each do |token|
+            resolved = self.class.resolve(token)
+            if resolved
+              @addresses << resolved
+            else
+              @options.merge!(self.class.normalize_key_names(token))
+            end
           end
         end
-      end
     end
   end
 end

data/lib/redis/store/namespace.rb

@@ -36,15 +36,15 @@ class Redis
       end
 
       def keys(pattern = "*")
-        namespace(pattern) { |p| super(p).map{|key| strip_namespace(key) } }
+        namespace(pattern) { |p| super(p).map { |key| strip_namespace(key) } }
       end
 
       def del(*keys)
-        super(*keys.map {|key| interpolate(key) }) if keys.any?
+        super(*keys.map { |key| interpolate(key) }) if keys.any?
       end
 
       def watch(*keys)
-        super(*keys.map {|key| interpolate(key) }) if keys.any?
+        super(*keys.map { |key| interpolate(key) }) if keys.any?
       end
 
       def mget(*keys, &blk)
@@ -52,15 +52,15 @@ class Redis
         if keys.any?
           # Serialization gets extended before Namespace does, so we need to pass options further
           if singleton_class.ancestors.include? Serialization
-            super(*keys.map {|key| interpolate(key) }, options, &blk)
+            super(*keys.map { |key| interpolate(key) }, options, &blk)
           else
-            super(*keys.map {|key| interpolate(key) }, &blk)
+            super(*keys.map { |key| interpolate(key) }, &blk)
           end
         end
       end
 
       def expire(key, ttl)
-         namespace(key) { |k| super(k, ttl) }
+        namespace(key) { |k| super(k, ttl) }
       end
 
       def to_s

data/lib/redis/store/redis_version.rb

@@ -11,4 +11,3 @@ class Redis
     end
   end
 end
-

data/lib/redis/store/version.rb

@@ -1,5 +1,5 @@
 class Redis
   class Store < self
-    VERSION = '1.5.0'
+    VERSION = '1.6.0'
   end
 end

data/redis-store.gemspec

@@ -1,4 +1,5 @@
 # -*- encoding: utf-8 -*-
+
 $:.push File.expand_path('../lib', __FILE__)
 require 'redis/store/version'
 
@@ -8,14 +9,14 @@ Gem::Specification.new do |s|
   s.authors     = ['Luca Guidi']
   s.email       = ['me@lucaguidi.com']
   s.homepage    = 'http://redis-store.org/redis-store'
-  s.summary     = %q{Redis stores for Ruby frameworks}
-  s.description = %q{Namespaced Rack::Session, Rack::Cache, I18n and cache Redis stores for Ruby web frameworks.}
+  s.summary     = 'Redis stores for Ruby frameworks'
+  s.description = 'Namespaced Rack::Session, Rack::Cache, I18n and cache Redis stores for Ruby web frameworks.'
 
   s.rubyforge_project = 'redis-store'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   s.require_paths = ["lib"]
   s.license       = 'MIT'
 
@@ -30,4 +31,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'pry',      '~> 0.10.4'
   s.add_development_dependency 'redis-store-testing'
   s.add_development_dependency 'appraisal', '~> 2.0'
+  s.add_development_dependency 'rubocop', '~> 0.54'
 end

data/test/redis/distributed_store_test.rb

@@ -3,8 +3,8 @@ require 'test_helper'
 describe "Redis::DistributedStore" do
   def setup
     @dmr = Redis::DistributedStore.new [
-      {:host => "localhost", :port => "6380", :db => 0},
-      {:host => "localhost", :port => "6381", :db => 0}
+      { :host => "localhost", :port => "6380", :db => 0 },
+      { :host => "localhost", :port => "6381", :db => 0 }
     ]
     @rabbit = OpenStruct.new :name => "bunny"
     @white_rabbit = OpenStruct.new :color => "white"
@@ -67,8 +67,8 @@ describe "Redis::DistributedStore" do
 
   it "passes through ring replica options" do
     dmr = Redis::DistributedStore.new [
-                                    {:host => "localhost", :port => "6380", :db => 0},
-                                    {:host => "localhost", :port => "6381", :db => 0}
+                                    { :host => "localhost", :port => "6380", :db => 0 },
+                                    { :host => "localhost", :port => "6381", :db => 0 }
                                 ], replicas: 1024
     dmr.ring.replicas.must_equal 1024
   end
@@ -76,8 +76,8 @@ describe "Redis::DistributedStore" do
   it "uses a custom ring object" do
     my_ring = Redis::HashRing.new
     dmr = Redis::DistributedStore.new [
-                                          {:host => "localhost", :port => "6380", :db => 0},
-                                          {:host => "localhost", :port => "6381", :db => 0}
+                                          { :host => "localhost", :port => "6380", :db => 0 },
+                                          { :host => "localhost", :port => "6381", :db => 0 }
                                       ], ring: my_ring
     dmr.ring.must_equal my_ring
     dmr.ring.nodes.length.must_equal 2
@@ -100,8 +100,8 @@ describe "Redis::DistributedStore" do
   describe "namespace" do
     it "uses namespaced key" do
       @dmr = Redis::DistributedStore.new [
-        {:host => "localhost", :port => "6380", :db => 0},
-        {:host => "localhost", :port => "6381", :db => 0}
+        { :host => "localhost", :port => "6380", :db => 0 },
+        { :host => "localhost", :port => "6381", :db => 0 }
       ], :namespace => "theplaylist"
 
       @dmr.expects(:node_for).with("theplaylist:rabbit").returns(@dmr.nodes.first)

data/test/redis/store/factory_test.rb

@@ -22,6 +22,11 @@ describe "Redis::Store::Factory" do
         store.to_s.must_equal("Redis Client connected to localhost:6380 against DB 0")
       end
 
+      it "uses specified scheme" do
+        store = Redis::Store::Factory.create :scheme => "rediss"
+        store.instance_variable_get(:@client).scheme.must_equal('rediss')
+      end
+
       it "uses specified path" do
         store = Redis::Store::Factory.create :path => "/var/run/redis.sock"
         store.to_s.must_equal("Redis Client connected to /var/run/redis.sock against DB 0")
@@ -69,6 +74,23 @@ describe "Redis::Store::Factory" do
         store.instance_variable_get(:@options)[:raw].must_equal(false)
       end
 
+      describe "defaults" do
+        it "defaults to localhost if no host specified" do
+          store = Redis::Store::Factory.create
+          store.instance_variable_get(:@client).host.must_equal('127.0.0.1')
+        end
+
+        it "defaults to 6379 if no port specified" do
+          store = Redis::Store::Factory.create
+          store.instance_variable_get(:@client).port.must_equal(6379)
+        end
+
+        it "defaults to redis:// if no scheme specified" do
+          store = Redis::Store::Factory.create
+          store.instance_variable_get(:@client).scheme.must_equal('redis')
+        end
+      end
+
       describe 'with stdout disabled' do
         before do
           @original_stderr = $stderr
@@ -98,11 +120,11 @@ describe "Redis::Store::Factory" do
 
       it "should instantiate a Redis::DistributedStore store" do
         store = Redis::Store::Factory.create(
-          {:host => "localhost", :port => 6379},
-          {:host => "localhost", :port => 6380}
+          { :host => "localhost", :port => 6379 },
+          { :host => "localhost", :port => 6380 }
         )
         store.must_be_kind_of(Redis::DistributedStore)
-        store.nodes.map {|node| node.to_s }.must_equal([
+        store.nodes.map { |node| node.to_s }.must_equal([
           "Redis Client connected to localhost:6379 against DB 0",
           "Redis Client connected to localhost:6380 against DB 0",
         ])
@@ -120,6 +142,16 @@ describe "Redis::Store::Factory" do
         store.to_s.must_equal("Redis Client connected to 127.0.0.1:6380 against DB 0")
       end
 
+      it "uses specified scheme" do
+        store = Redis::Store::Factory.create "rediss://127.0.0.1:6380"
+        store.instance_variable_get(:@client).scheme.must_equal('rediss')
+      end
+
+      it "correctly defaults to redis:// when relative scheme specified" do
+        store = Redis::Store::Factory.create "//127.0.0.1:6379"
+        store.instance_variable_get(:@client).scheme.must_equal('redis')
+      end
+
       it "uses specified path" do
         store = Redis::Store::Factory.create "unix:///var/run/redis.sock"
         store.to_s.must_equal("Redis Client connected to /var/run/redis.sock against DB 0")
@@ -174,50 +206,50 @@ describe "Redis::Store::Factory" do
       it "instantiates Redis::DistributedStore" do
         store = Redis::Store::Factory.create "redis://127.0.0.1:6379", "redis://127.0.0.1:6380"
         store.must_be_kind_of(Redis::DistributedStore)
-        store.nodes.map {|node| node.to_s }.must_equal([
+        store.nodes.map { |node| node.to_s }.must_equal([
           "Redis Client connected to 127.0.0.1:6379 against DB 0",
           "Redis Client connected to 127.0.0.1:6380 against DB 0",
         ])
       end
     end
 
-    describe 'when given host Hash and options Hash' do 
+    describe 'when given host Hash and options Hash' do
       it 'instantiates Redis::Store and merges options' do
         store = Redis::Store::Factory.create(
-          { :host => '127.0.0.1', :port => '6379' }, 
+          { :host => '127.0.0.1', :port => '6379' },
           { :namespace => 'theplaylist' }
         )
       end
 
-      it 'instantiates Redis::DistributedStore and merges options' do 
+      it 'instantiates Redis::DistributedStore and merges options' do
         store = Redis::Store::Factory.create(
-          { :host => '127.0.0.1', :port => '6379' }, 
-          { :host => '127.0.0.1', :port => '6380' }, 
+          { :host => '127.0.0.1', :port => '6379' },
+          { :host => '127.0.0.1', :port => '6380' },
           { :namespace => 'theplaylist' }
         )
-        store.nodes.map {|node| node.to_s }.must_equal([
+        store.nodes.map { |node| node.to_s }.must_equal([
           "Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist",
           "Redis Client connected to 127.0.0.1:6380 against DB 0 with namespace theplaylist"
         ])
       end
     end
 
-    describe 'when given host String and options Hash' do 
-      it 'instantiates Redis::Store and merges options' do 
-        store = Redis::Store::Factory.create "redis://127.0.0.1", { :namespace => 'theplaylist' }
+    describe 'when given host String and options Hash' do
+      it 'instantiates Redis::Store and merges options' do
+        store = Redis::Store::Factory.create "redis://127.0.0.1", :namespace => 'theplaylist'
         store.to_s.must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist")
       end
 
-      it 'instantiates Redis::DistributedStore and merges options' do 
-        store = Redis::Store::Factory.create "redis://127.0.0.1:6379", "redis://127.0.0.1:6380", { :namespace => 'theplaylist' }
-        store.nodes.map {|node| node.to_s }.must_equal([
+      it 'instantiates Redis::DistributedStore and merges options' do
+        store = Redis::Store::Factory.create "redis://127.0.0.1:6379", "redis://127.0.0.1:6380", :namespace => 'theplaylist'
+        store.nodes.map { |node| node.to_s }.must_equal([
           "Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist",
           "Redis Client connected to 127.0.0.1:6380 against DB 0 with namespace theplaylist",
         ])
       end
 
       it 'instantiates Redis::Store and sets namespace from String' do
-        store = Redis::Store::Factory.create "redis://127.0.0.1:6379/0/theplaylist", { :expire_after => 5 }
+        store = Redis::Store::Factory.create "redis://127.0.0.1:6379/0/theplaylist", :expire_after => 5
         store.to_s.must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist")
       end
     end

data/test/redis/store/interface_test.rb

@@ -10,18 +10,18 @@ describe Redis::Store::Interface do
   end
 
   it "should get an element" do
-    lambda { @r.get("key", :option => true) } #.wont_raise ArgumentError
+    lambda { @r.get("key", :option => true) } # .wont_raise ArgumentError
   end
 
   it "should set an element" do
-    lambda { @r.set("key", "value", :option => true) } #.wont_raise ArgumentError
+    lambda { @r.set("key", "value", :option => true) } # .wont_raise ArgumentError
   end
 
   it "should setnx an element" do
-    lambda { @r.setnx("key", "value", :option => true) } #.wont_raise ArgumentError
+    lambda { @r.setnx("key", "value", :option => true) } # .wont_raise ArgumentError
   end
 
   it "should setex an element" do
-    lambda { @r.setex("key", 1, "value", :option => true) } #.wont_raise ArgumentError
+    lambda { @r.setex("key", 1, "value", :option => true) } # .wont_raise ArgumentError
   end
 end

data/test/redis/store/namespace_test.rb

@@ -90,52 +90,52 @@ describe "Redis::Store::Namespace" do
   end
 
   describe 'method calls' do
-    let(:store){Redis::Store.new :namespace => @namespace, :serializer => nil}
-    let(:client){store.instance_variable_get(:@client)}
+    let(:store) { Redis::Store.new :namespace => @namespace, :serializer => nil }
+    let(:client) { store.instance_variable_get(:@client) }
 
     it "should namespace get" do
-       client.expects(:call).with([:get, "#{@namespace}:rabbit"]).once
-       store.get("rabbit")
+      client.expects(:call).with([:get, "#{@namespace}:rabbit"]).once
+      store.get("rabbit")
     end
 
     it "should namespace set" do
-       client.expects(:call).with([:set, "#{@namespace}:rabbit", @rabbit])
-       store.set "rabbit", @rabbit
+      client.expects(:call).with([:set, "#{@namespace}:rabbit", @rabbit])
+      store.set "rabbit", @rabbit
     end
 
     it "should namespace setnx" do
-       client.expects(:call).with([:setnx, "#{@namespace}:rabbit", @rabbit])
-       store.setnx "rabbit", @rabbit
+      client.expects(:call).with([:setnx, "#{@namespace}:rabbit", @rabbit])
+      store.setnx "rabbit", @rabbit
     end
 
     it "should namespace del with single key" do
-       client.expects(:call).with([:del, "#{@namespace}:rabbit"])
-       store.del "rabbit"
+      client.expects(:call).with([:del, "#{@namespace}:rabbit"])
+      store.del "rabbit"
     end
 
     it "should namespace del with multiple keys" do
-       client.expects(:call).with([:del, "#{@namespace}:rabbit", "#{@namespace}:white_rabbit"])
-       store.del "rabbit", "white_rabbit"
+      client.expects(:call).with([:del, "#{@namespace}:rabbit", "#{@namespace}:white_rabbit"])
+      store.del "rabbit", "white_rabbit"
     end
 
     it "should namespace keys" do
-       store.set "rabbit", @rabbit
-       store.keys("rabb*").must_equal [ "rabbit" ]
+      store.set "rabbit", @rabbit
+      store.keys("rabb*").must_equal [ "rabbit" ]
     end
 
     it "should namespace exists" do
-       client.expects(:call).with([:exists, "#{@namespace}:rabbit"])
-       store.exists "rabbit"
+      client.expects(:call).with([:exists, "#{@namespace}:rabbit"])
+      store.exists "rabbit"
     end
 
     it "should namespace incrby" do
-       client.expects(:call).with([:incrby, "#{@namespace}:counter", 1])
-       store.incrby "counter", 1
+      client.expects(:call).with([:incrby, "#{@namespace}:counter", 1])
+      store.incrby "counter", 1
     end
 
     it "should namespace decrby" do
-       client.expects(:call).with([:decrby, "#{@namespace}:counter", 1])
-       store.decrby "counter", 1
+      client.expects(:call).with([:decrby, "#{@namespace}:counter", 1])
+      store.decrby "counter", 1
     end
 
     it "should namespace mget" do
@@ -154,24 +154,24 @@ describe "Redis::Store::Namespace" do
     end
 
     it "should namespace expire" do
-       client.expects(:call).with([:expire, "#{@namespace}:rabbit", 60]).once
-       store.expire("rabbit",60)
+      client.expects(:call).with([:expire, "#{@namespace}:rabbit", 60]).once
+      store.expire("rabbit", 60)
     end
 
     it "should namespace ttl" do
-       client.expects(:call).with([:ttl, "#{@namespace}:rabbit"]).once
-       store.ttl("rabbit")
+      client.expects(:call).with([:ttl, "#{@namespace}:rabbit"]).once
+      store.ttl("rabbit")
     end
 
     it "should namespace watch" do
-      client.expects(:call).with([:watch,"#{@namespace}:rabbit"]).once
+      client.expects(:call).with([:watch, "#{@namespace}:rabbit"]).once
       store.watch("rabbit")
     end
 
     it "wraps flushdb with appropriate KEYS * calls" do
       client.expects(:call).with([:flushdb]).never
-      client.expects(:call).with([:keys,"#{@namespace}:*"]).once.returns(["rabbit"])
-      client.expects(:call).with([:del,"#{@namespace}:rabbit"]).once
+      client.expects(:call).with([:keys, "#{@namespace}:*"]).once.returns(["rabbit"])
+      client.expects(:call).with([:del, "#{@namespace}:rabbit"]).once
       store.flushdb
     end
 

data/test/redis/store/redis_version_test.rb

@@ -2,7 +2,7 @@ require 'test_helper'
 
 describe "Redis::RedisVersion" do
   def setup
-    @store  = Redis::Store.new
+    @store = Redis::Store.new
   end
 
   def teardown
@@ -26,4 +26,3 @@ describe "Redis::RedisVersion" do
     end
   end
 end
-

data/test/redis/store/serialization_test.rb

@@ -81,8 +81,8 @@ describe "Redis::Serialization" do
 
   it "marshals setex (over a distributed store)" do
     @store = Redis::DistributedStore.new [
-      {:host => "localhost", :port => "6380", :db => 0},
-      {:host => "localhost", :port => "6381", :db => 0}
+      { :host => "localhost", :port => "6380", :db => 0 },
+      { :host => "localhost", :port => "6381", :db => 0 }
     ]
     @store.setex "rabbit", 50, @white_rabbit
     @store.get("rabbit").must_equal(@white_rabbit)
@@ -90,8 +90,8 @@ describe "Redis::Serialization" do
 
   it "doesn't marshal setex if raw option is true (over a distributed store)" do
     @store = Redis::DistributedStore.new [
-      {:host => "localhost", :port => "6380", :db => 0},
-      {:host => "localhost", :port => "6381", :db => 0}
+      { :host => "localhost", :port => "6380", :db => 0 },
+      { :host => "localhost", :port => "6381", :db => 0 }
     ]
     @store.setex "rabbit", 50, @white_rabbit, :raw => true
     @store.get("rabbit", :raw => true).must_equal(%(#<OpenStruct color="white">))

data/test/redis/store/ttl_test.rb

@@ -50,7 +50,6 @@ class MockRedis
   def has_expire?(*a)
     @expires.include?(a)
   end
-
 end
 
 class MockTtlStore < MockRedis
@@ -80,7 +79,7 @@ describe MockTtlStore do
 
     describe 'with nx and ex option' do
       it 'must call super with key and value and options' do
-        set_options = {nx: true, ex: 3600}
+        set_options = { nx: true, ex: 3600 }
         redis.set(key, mock_value, set_options)
         redis.has_set?(key, mock_value, set_options).must_equal true
       end

data/test/test_helper.rb

@@ -16,6 +16,6 @@ module Kernel
     $VERBOSE = nil
     result = yield
     $VERBOSE = original_verbosity
-    return result
+    result
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-store
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Luca Guidi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-16 00:00:00.000000000 Z
+date: 2018-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -156,6 +156,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.54'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.54'
 description: Namespaced Rack::Session, Rack::Cache, I18n and cache Redis stores for
   Ruby web frameworks.
 email:
@@ -164,7 +178,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codeclimate.yml"
 - ".gitignore"
+- ".rubocop.yml"
 - ".travis.yml"
 - Appraisals
 - CHANGELOG.md
@@ -215,7 +231,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: redis-store
-rubygems_version: 2.7.3
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: Redis stores for Ruby frameworks