redis-store-pika 1.9.2.1

data/lib/redis/store.rb

@@ -0,0 +1,85 @@
+require 'redis'
+require 'redis/store/factory'
+require 'redis/distributed_store'
+require 'redis/store/namespace'
+require 'redis/store/serialization'
+require 'redis/store/version'
+require 'redis/store/redis_version'
+require 'redis/store/ttl'
+require 'redis/store/interface'
+require 'redis/store/redis_version'
+
+class Redis
+  class Store < self
+    include Ttl, Interface, RedisVersion
+
+    def initialize(options = {})
+      orig_options = options.dup
+
+      _remove_unsupported_options(options)
+      # The options here is updated
+      super(options)
+
+      unless orig_options[:marshalling].nil?
+        puts %(
+          DEPRECATED: You are passing the :marshalling option, which has been
+          replaced with `serializer: Marshal` to support pluggable serialization
+          backends. To disable serialization (much like disabling marshalling),
+          pass `serializer: nil` in your configuration.
+
+          The :marshalling option will be removed for redis-store 2.0.
+        )
+      end
+
+      @serializer = orig_options.key?(:serializer) ? orig_options.delete(:serializer) : Marshal
+
+      unless orig_options[:marshalling].nil?
+        # `marshalling` only used here, might not be supported in `super`
+        @serializer = orig_options.delete(:marshalling) ? Marshal : nil
+      end
+
+      _extend_marshalling
+      _extend_namespace orig_options
+    end
+
+    def reconnect
+      @client.reconnect
+    end
+
+    def to_s
+      "Redis Client connected to #{location} against DB #{@client.db}"
+    end
+
+    def location
+      if @client.path
+        @client.path
+      else
+        h = @client.host
+        h = "[#{h}]" if h.include?(":")
+        "#{h}:#{@client.port}"
+      end
+    end
+
+    private
+      def _remove_unsupported_options(options)
+        return unless self.class.redis_client_defined?
+
+        # Unsupported keywords should be removed to avoid errors
+        # https://github.com/redis-rb/redis-client/blob/v0.13.0/lib/redis_client/config.rb#L21
+        options.delete(:raw)
+        options.delete(:serializer)
+        options.delete(:marshalling)
+        options.delete(:namespace)
+        options.delete(:scheme)
+      end
+
+      def _extend_marshalling
+        extend Serialization unless @serializer.nil?
+      end
+
+      def _extend_namespace(options)
+        @namespace = options[:namespace]
+        extend Namespace
+      end
+  end
+end

data/lib/redis-store-pika.rb

@@ -0,0 +1 @@
+require 'redis-store'

data/lib/redis-store.rb

@@ -0,0 +1 @@
+require 'redis/store'

data/redis-store.gemspec

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+
+$:.push File.expand_path('../lib', __FILE__)
+require 'redis/store/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'redis-store-pika'
+  s.version     = Redis::Store::VERSION
+  s.authors     = ['Luca Guidi']
+  s.email       = ['me@lucaguidi.com']
+  s.homepage    = 'https://github.com/PikachuEXE/redis-store'
+  s.summary     = 'Redis stores for Ruby frameworks'
+  s.description = 'Namespaced Rack::Session, Rack::Cache, I18n and cache Redis stores for Ruby web frameworks.'
+  s.post_install_message = "
+    This is a fork of official redis-store gem published to let people use fixes unavailable on official one yet.
+    Be sure to check updates from official redis-store gem sometimes in case the fixes here are merged there.
+  "
+
+  s.files         = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+  s.license       = 'MIT'
+
+  s.add_dependency 'redis', '>= 4', '< 6'
+
+  s.add_development_dependency 'rake',     '>= 12.3.3'
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'mocha',    '~> 2.1.0'
+  s.add_development_dependency 'minitest', '~> 5'
+  s.add_development_dependency 'git',      '~> 1.2'
+  s.add_development_dependency 'pry-nav',  '~> 0.2.4'
+  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

@@ -0,0 +1,111 @@
+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 }
+    ]
+    @rabbit = OpenStruct.new :name => "bunny"
+    @white_rabbit = OpenStruct.new :color => "white"
+    @dmr.set "rabbit", @rabbit
+  end
+
+  def teardown
+    @dmr.ring.nodes.each { |server| server.flushdb }
+  end
+
+  it "accepts connection params" do
+    dmr = Redis::DistributedStore.new [ :host => "localhost", :port => "6380", :db => "1" ]
+    _(dmr.ring.nodes.size).must_equal(1)
+    mr = dmr.ring.nodes.first
+    _(mr.to_s).must_equal("Redis Client connected to localhost:6380 against DB 1")
+  end
+
+  it "forces reconnection" do
+    @dmr.nodes.each do |node|
+      node.expects(:reconnect)
+    end
+
+    @dmr.reconnect
+  end
+
+  it "sets an object" do
+    @dmr.set "rabbit", @white_rabbit
+    _(@dmr.get("rabbit")).must_equal(@white_rabbit)
+  end
+
+  it "gets an object" do
+    _(@dmr.get("rabbit")).must_equal(@rabbit)
+  end
+
+  it "mget" do
+    @dmr.set "rabbit2", @white_rabbit
+    begin
+      @dmr.mget "rabbit", "rabbit2" do |rabbits|
+        rabbit, rabbit2 = rabbits
+        _(rabbits.length).must_equal(2)
+        _(rabbit).must_equal(@rabbit)
+        _(rabbit2).must_equal(@white_rabbit)
+      end
+    rescue Redis::Distributed::CannotDistribute
+      # Not supported on redis-rb < 4, and hence Ruby < 2.2.
+    end
+  end
+
+  it "mapped_mget" do
+    @dmr.set "rabbit2", @white_rabbit
+    begin
+      result = @dmr.mapped_mget("rabbit", "rabbit2")
+      _(result.keys).must_equal %w[ rabbit rabbit2 ]
+      _(result["rabbit"]).must_equal @rabbit
+      _(result["rabbit2"]).must_equal @white_rabbit
+    rescue Redis::Distributed::CannotDistribute
+      # Not supported on redis-rb < 4, and hence Ruby < 2.2.
+    end
+  end
+
+  it "passes through ring replica options" do
+    dmr = Redis::DistributedStore.new [
+                                    { :host => "localhost", :port => "6380", :db => 0 },
+                                    { :host => "localhost", :port => "6381", :db => 0 }
+                                ], replicas: 1024
+    _(dmr.ring.replicas).must_equal 1024
+  end
+
+  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 }
+                                      ], ring: my_ring
+    _(dmr.ring).must_equal my_ring
+    _(dmr.ring.nodes.length).must_equal 2
+  end
+
+  describe '#redis_version' do
+    it 'returns redis version' do
+      @dmr.nodes.first.expects(:redis_version)
+      @dmr.redis_version
+    end
+  end
+
+  describe '#supports_redis_version?' do
+    it 'returns redis version' do
+      @dmr.nodes.first.expects(:supports_redis_version?).with('2.8.0')
+      @dmr.supports_redis_version?('2.8.0')
+    end
+  end
+
+  describe "namespace" do
+    it "uses namespaced key" do
+      @dmr = Redis::DistributedStore.new [
+        { :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)
+      @dmr.get "rabbit"
+    end
+  end
+end unless ENV['CI']

data/test/redis/store/factory_test.rb

@@ -0,0 +1,273 @@
+require 'test_helper'
+require 'json'
+
+describe "Redis::Store::Factory" do
+  describe ".create" do
+    describe "when not given any arguments" do
+      it "instantiates Redis::Store" do
+        store = Redis::Store::Factory.create
+        _(store).must_be_kind_of(Redis::Store)
+        # `redis.rb` use different default host values in v4 & v5
+        _(store.to_s).must_match(%r{^Redis Client connected to (127.0.0.1|localhost):6379 against DB 0$})
+      end
+    end
+
+    describe "when given a Hash" do
+      it "uses specified host" do
+        store = Redis::Store::Factory.create :host => "localhost"
+        _(store.to_s).must_equal("Redis Client connected to localhost:6379 against DB 0")
+      end
+
+      it "uses specified port" do
+        store = Redis::Store::Factory.create :host => "localhost", :port => 6380
+        _(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"
+        client = store.instance_variable_get(:@client)
+        # `redis-client` does NOT have `scheme`
+        client.respond_to?(:scheme) && _(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")
+      end
+
+      it "uses specified db" do
+        store = Redis::Store::Factory.create :host => "localhost", :port => 6380, :db => 13
+        _(store.to_s).must_equal("Redis Client connected to localhost:6380 against DB 13")
+      end
+
+      it "uses specified namespace" do
+        store = Redis::Store::Factory.create :namespace => "theplaylist"
+        # `redis.rb` use different default host values in v4 & v5
+        _(store.to_s).must_match(%r{^Redis Client connected to (127.0.0.1|localhost):6379 against DB 0 with namespace theplaylist$})
+      end
+
+      it "uses specified key_prefix as namespace" do
+        store = Redis::Store::Factory.create :key_prefix => "theplaylist"
+        # `redis.rb` use different default host values in v4 & v5
+        _(store.to_s).must_match(%r{^Redis Client connected to (127.0.0.1|localhost):6379 against DB 0 with namespace theplaylist$})
+      end
+
+      it "uses specified password" do
+        store = Redis::Store::Factory.create :password => "secret"
+        _(store.instance_variable_get(:@client).password).must_equal("secret")
+      end
+
+      it 'uses empty password' do
+        store = Redis::Store::Factory.create :password => ''
+        _(store.instance_variable_get(:@client).password).must_equal('')
+      end
+
+      it 'uses nil password' do
+        store = Redis::Store::Factory.create :password => nil
+        assert_nil(store.instance_variable_get(:@client).password)
+      end
+
+      it "disables serialization" do
+        store = Redis::Store::Factory.create :serializer => nil
+        _(store.instance_variable_get(:@serializer)).must_be_nil
+        # `raw` would be removed when `redis-client` is used
+        defined?(::RedisClient) || _(store.instance_variable_get(:@options)[:raw]).must_equal(true)
+      end
+
+      it "configures pluggable serialization backend" do
+        store = Redis::Store::Factory.create :serializer => JSON
+        _(store.instance_variable_get(:@serializer)).must_equal(JSON)
+        # `raw` would be removed when `redis-client` is used
+        defined?(::RedisClient) || _(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
+          # `redis.rb` use different default host values in v4 & v5
+          _(store.instance_variable_get(:@client).host).must_match(%r{^127.0.0.1|localhost$})
+        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
+          client = store.instance_variable_get(:@client)
+          # `redis-client` does NOT have `scheme`
+          client.respond_to?(:scheme) && _(client.scheme).must_equal('redis')
+        end
+      end
+
+      describe 'with stdout disabled' do
+        before do
+          @original_stderr = $stderr
+          @original_stdout = $stdout
+
+          $stderr = Tempfile.new('stderr')
+          $stdout = Tempfile.new('stdout')
+        end
+
+        it "disables marshalling and provides deprecation warning" do
+          store = Redis::Store::Factory.create :marshalling => false
+          _(store.instance_variable_get(:@serializer)).must_be_nil
+          # `raw` would be removed when `redis-client` is used
+          defined?(::RedisClient) || _(store.instance_variable_get(:@options)[:raw]).must_equal(true)
+        end
+
+        it "enables marshalling but provides warning to use :serializer instead" do
+          store = Redis::Store::Factory.create :marshalling => true
+          _(store.instance_variable_get(:@serializer)).must_equal(Marshal)
+          # `raw` would be removed when `redis-client` is used
+          defined?(::RedisClient) || _(store.instance_variable_get(:@options)[:raw]).must_equal(false)
+        end
+
+        after do
+          $stderr = @original_stderr
+          $stdout = @original_stdout
+        end
+      end
+
+      it "should instantiate a Redis::DistributedStore store" do
+        store = Redis::Store::Factory.create(
+          { :host => "localhost", :port => 6379 },
+          { :host => "localhost", :port => 6380 }
+        )
+        _(store).must_be_kind_of(Redis::DistributedStore)
+        _(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",
+        ])
+      end
+    end
+
+    describe "when given a String" do
+      it "uses specified host" do
+        store = Redis::Store::Factory.create "redis://127.0.0.1"
+        _(store.to_s).must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0")
+      end
+
+      it "uses specified port" do
+        store = Redis::Store::Factory.create "redis://127.0.0.1:6380"
+        _(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"
+        client = store.instance_variable_get(:@client)
+        # `redis-client` does NOT have `scheme`
+        client.respond_to?(:scheme) && _(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"
+        client = store.instance_variable_get(:@client)
+        # `redis-client` does NOT have `scheme`
+        client.respond_to?(:scheme) && _(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")
+      end
+
+      it "uses specified db" do
+        store = Redis::Store::Factory.create "redis://127.0.0.1:6380/13"
+        _(store.to_s).must_equal("Redis Client connected to 127.0.0.1:6380 against DB 13")
+      end
+
+      it "uses specified namespace" do
+        store = Redis::Store::Factory.create "redis://127.0.0.1:6379/0/theplaylist"
+        _(store.to_s).must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist")
+      end
+
+      it "uses specified via query namespace" do
+        store = Redis::Store::Factory.create "redis://127.0.0.1:6379/0?namespace=theplaylist"
+        _(store.to_s).must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist")
+      end
+
+      it "uses specified namespace with path" do
+        store = Redis::Store::Factory.create "unix:///var/run/redis.sock?db=2&namespace=theplaylist"
+        _(store.to_s).must_equal("Redis Client connected to /var/run/redis.sock against DB 2 with namespace theplaylist")
+      end
+
+      it "uses specified password" do
+        store = Redis::Store::Factory.create "redis://:secret@127.0.0.1:6379/0/theplaylist"
+        _(store.instance_variable_get(:@client).password).must_equal("secret")
+      end
+
+      it 'uses specified password with special characters' do
+        store = Redis::Store::Factory.create 'redis://:pwd%40123@127.0.0.1:6379/0/theplaylist'
+        _(store.instance_variable_get(:@client).password).must_equal('pwd@123')
+      end
+
+      it 'uses empty password' do
+        store = Redis::Store::Factory.create 'redis://:@127.0.0.1:6379/0/theplaylist'
+        _(store.instance_variable_get(:@client).password).must_equal('')
+      end
+
+      it 'uses nil password' do
+        store = Redis::Store::Factory.create 'redis://127.0.0.1:6379/0/theplaylist'
+        assert_nil(store.instance_variable_get(:@client).password)
+      end
+
+      it "correctly uses specified ipv6 host" do
+        store = Redis::Store::Factory.create "redis://[::1]:6380"
+        _(store.to_s).must_equal("Redis Client connected to [::1]:6380 against DB 0")
+        _(store.instance_variable_get('@options')[:host]).must_equal("::1")
+      end
+
+      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([
+          "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
+      it 'instantiates Redis::Store and merges options' do
+        Redis::Store::Factory.create(
+          { :host => '127.0.0.1', :port => '6379' },
+          { :namespace => 'theplaylist' }
+        )
+      end
+
+      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' },
+          { :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
+    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'
+        _(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([
+          "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"
+        _(store.to_s).must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist")
+      end
+    end
+  end
+end

data/test/redis/store/interface_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class InterfacedRedis < Redis
+  include Redis::Store::Interface
+end
+
+describe Redis::Store::Interface do
+  before do
+    @r = InterfacedRedis.new
+  end
+
+  it "should get an element" do
+    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
+  end
+
+  it "should setnx an element" do
+    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
+  end
+end