redis-store-pika 1.9.2.1

data/README.md

@@ -0,0 +1,68 @@
+# This is a fork!
+
+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`](https://github.com/redis-store/redis-store) gem sometimes in case the fixes included in this fork are already merged there.  
+(You can subscribe specific issues/PRs/releases on GitHub)  
+
+To install this fork place `redis-store-pika` into Gemfile (no special `require` option needed, I think).  
+Be sure not to install/require `redis-store` at the same time (maybe comment that line out in `Gemfile`)  
+
+## Versioning
+Since this is a fork (as a temporary measure) semantic versioning won't be used.  
+It would be like `(last offical version)` + `.x` (`x` = how many times it's released)  
+(e.g. Based on `1.9.2` + 1st release = `1.9.2.1`)  
+
+# Redis stores for Ruby frameworks
+
+__Redis Store__ provides a full set of stores (*Cache*, *I18n*, *Session*, *HTTP Cache*) for modern Ruby frameworks like: __Ruby on Rails__, __Sinatra__, __Rack__, __Rack::Cache__ and __I18n__. It supports object marshalling, timeouts, single or multiple nodes, and namespaces.
+
+Please check the *README* file of each gem for usage and installation guidelines.
+
+## Redis Installation
+
+### Option 1: Homebrew
+
+MacOS X users should use [Homebrew](https://github.com/mxcl/homebrew) to install Redis:
+
+```shell
+brew install redis
+```
+
+### Option 2: From Source
+
+Download and install Redis from [the download page](http://redis.io//download) and follow the instructions.
+
+## Running tests
+
+```ruby
+git clone git://github.com/redis-store/redis-store.git
+cd redis-store
+bundle install
+bundle exec rake
+```
+
+If you are on **Snow Leopard** you have to run `env ARCHFLAGS="-arch x86_64" ruby ci/run.rb`
+
+## Contributors
+
+https://github.com/redis-store/redis-store/graphs/contributors
+
+## Versioning
+
+The **redis-store** family of gems uses [Semantic Versioning](http://semver.org), meaning gems depending on **redis-store**
+can be reliably inclusive of any version between the current and the next major. We recommend the following dependency
+in your library's gemspec:
+
+```ruby
+s.add_dependency 'redis-store', '>= 1.4', '< 2'
+```
+
+## Status
+
+[![Gem Version](https://badge.fury.io/rb/redis-store.svg)](http://badge.fury.io/rb/redis-store)
+[![Build Status](https://secure.travis-ci.org/redis-store/redis-store.svg?branch=master)](http://travis-ci.org/redis-store/redis-store?branch=master)
+[![Code Climate](https://codeclimate.com/github/redis-store/redis-store.svg)](https://codeclimate.com/github/redis-store/redis-store)
+
+## Copyright
+
+2009 - 2013 Luca Guidi - [http://lucaguidi.com](http://lucaguidi.com), released under the MIT license.

data/Rakefile

@@ -0,0 +1,15 @@
+require 'bundler/setup'
+require 'rake'
+require 'bundler/gem_tasks'
+require 'appraisal'
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new :lint
+
+if !ENV["APPRAISAL_INITIALIZED"] && !ENV["CI"]
+  task :default do
+    sh "appraisal install && rake appraisal default"
+  end
+else
+  require 'redis-store/testing/tasks'
+end

data/gemfiles/redis_4_0_x.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "redis", "~> 4.0.0"
+
+gemspec path: "../"

data/gemfiles/redis_4_1_x.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "redis", "~> 4.1.0"
+
+gemspec path: "../"

data/gemfiles/redis_4_6_x.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "redis", "~> 4.6.0"
+
+gemspec path: "../"

data/gemfiles/redis_4_x.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "redis", "~> 4.0"
+
+gemspec path: "../"

data/gemfiles/redis_5_x.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "redis", "~> 5.0"
+
+gemspec path: "../"

data/lib/redis/distributed_store.rb

@@ -0,0 +1,68 @@
+require 'redis/distributed'
+
+class Redis
+  class DistributedStore < Distributed
+    @@timeout = 5
+    attr_reader :ring
+
+    def initialize(addresses, options = {})
+      _extend_namespace options
+      # `@tag` introduced in `redis-rb` 5.0
+      @tag = options[:tag] || /^\{(.+?)\}/
+      @ring = options[:ring] || Redis::HashRing.new([], options[:replicas] || Redis::HashRing::POINTS_PER_SERVER)
+
+      addresses.each do |address|
+        @ring.add_node(::Redis::Store.new _merge_options(address, options))
+      end
+    end
+
+    def nodes
+      ring.nodes
+    end
+
+    def reconnect
+      nodes.each { |node| node.reconnect }
+    end
+
+    def set(key, value, options = nil)
+      node_for(key).set(key, value, options)
+    end
+
+    def get(key, options = nil)
+      node_for(key).get(key, options)
+    end
+
+    def setnx(key, value, options = nil)
+      node_for(key).setnx(key, value, options)
+    end
+
+    def redis_version
+      nodes.first.redis_version unless nodes.empty?
+    end
+
+    def supports_redis_version?(version)
+      if nodes.empty?
+        false
+      else
+        nodes.first.supports_redis_version?(version)
+      end
+    end
+
+    def setex(key, expiry, value, options = nil)
+      node_for(key).setex(key, expiry, value, options)
+    end
+
+    private
+      def _extend_namespace(options)
+        @namespace = options[:namespace]
+        extend ::Redis::Store::Namespace if @namespace
+      end
+
+      def _merge_options(address, options)
+        address.merge(
+          :timeout => options[:timeout] || @@timeout,
+          :namespace => options[:namespace]
+        )
+      end
+  end
+end

data/lib/redis/store/factory.rb

@@ -0,0 +1,111 @@
+require 'cgi'
+require 'uri'
+
+class Redis
+  class Store < self
+    class Factory
+      DEFAULT_PORT = 6379
+
+      def self.create(*options)
+        new(options).create
+      end
+
+      def initialize(*options)
+        @addresses = []
+        @options   = {}
+        extract_addresses_and_options(options)
+      end
+
+      def create
+        if @addresses.empty?
+          @addresses << {}
+        end
+
+        if @addresses.size > 1
+          ::Redis::DistributedStore.new @addresses, @options
+        else
+          ::Redis::Store.new @addresses.first.merge(@options)
+        end
+      end
+
+      def self.resolve(uri) #:api: private
+        if uri.is_a?(Hash)
+          extract_host_options_from_hash(uri)
+        else
+          extract_host_options_from_uri(uri)
+        end
+      end
+
+      def self.extract_host_options_from_hash(options)
+        options = normalize_key_names(options)
+        if host_options?(options)
+          options
+        else
+          nil
+        end
+      end
+
+      def self.normalize_key_names(options)
+        options = options.dup
+        if options.key?(:key_prefix) && !options.key?(:namespace)
+          options[:namespace] = options.delete(:key_prefix) # RailsSessionStore
+        end
+        options[:raw] = case
+                        when options.key?(:serializer)
+                          options[:serializer].nil?
+                        when options.key?(:marshalling)
+                          !options[:marshalling]
+                        else
+                          false
+        end
+        options
+      end
+
+      def self.host_options?(options)
+        options.keys.any? { |n| [:host, :db, :port, :path].include?(n) }
+      end
+
+      def self.extract_host_options_from_uri(uri)
+        uri = URI.parse(uri)
+        if uri.scheme == "unix"
+          options = { :path => uri.path }
+        else
+          _, db, namespace = if uri.path
+            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)
+          }
+
+          options[:db]        = db.to_i   if db
+          options[:namespace] = namespace if namespace
+        end
+        if uri.query
+          query = Hash[URI.decode_www_form(uri.query)]
+          query.each do |(key, value)|
+            options[key.to_sym] = value
+          end
+        end
+
+        options
+      end
+
+      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))
+            end
+          end
+        end
+    end
+  end
+end

data/lib/redis/store/interface.rb

@@ -0,0 +1,29 @@
+class Redis
+  class Store < self
+    module Interface
+      def get(key, options = nil)
+        super(key)
+      end
+
+      REDIS_SET_OPTIONS = %i(ex px nx xx keepttl).freeze
+      private_constant :REDIS_SET_OPTIONS
+
+      def set(key, value, options = nil)
+        if options && REDIS_SET_OPTIONS.any? { |k| options.key?(k) }
+          kwargs = REDIS_SET_OPTIONS.each_with_object({}) { |key, h| h[key] = options[key] if options.key?(key) }
+          super(key, value, **kwargs)
+        else
+          super(key, value)
+        end
+      end
+
+      def setnx(key, value, options = nil)
+        super(key, value)
+      end
+
+      def setex(key, expiry, value, options = nil)
+        super(key, expiry, value)
+      end
+    end
+  end
+end

data/lib/redis/store/namespace.rb

@@ -0,0 +1,211 @@
+class Redis
+  class Store < self
+    module Namespace
+      FLUSHDB_BATCH_SIZE = 1000
+
+      def set(key, *args)
+        namespace(key) { |k| super(k, *args) }
+      end
+
+      def setex(key, *args)
+        namespace(key) { |k| super(k, *args) }
+      end
+
+      def setnx(key, *args)
+        namespace(key) { |k| super(k, *args) }
+      end
+
+      def ttl(key, options = nil)
+        namespace(key) { |k| super(k) }
+      end
+
+      def get(key, *args)
+        namespace(key) { |k| super(k, *args) }
+      end
+
+      def exists(*keys)
+        super(*keys.map { |key| interpolate(key) })
+      end
+
+      def exists?(*keys)
+        super(*keys.map { |key| interpolate(key) })
+      end
+
+      def incrby(key, increment)
+        namespace(key) { |k| super(k, increment) }
+      end
+
+      def decrby(key, increment)
+        namespace(key) { |k| super(k, increment) }
+      end
+
+      def keys(pattern = "*")
+        namespace(pattern) { |p| super(p).map { |key| strip_namespace(key) } }
+      end
+
+      def scan(cursor, match: nil, **kwargs)
+        if match
+          namespace(match) do |pattern|
+            cursor, keys = super(cursor, match: pattern, **kwargs)
+            [ cursor, keys.map { |key| strip_namespace(key) } ]
+          end
+        else
+          super(cursor, **kwargs)
+        end
+      end
+
+      def del(*keys)
+        super(*keys.map { |key| interpolate(key) }) if keys.any?
+      end
+
+      def unlink(*keys)
+        super(*keys.map { |key| interpolate(key) }) if keys.any?
+      end
+
+      def watch(*keys)
+        super(*keys.map { |key| interpolate(key) }) if keys.any?
+      end
+
+      def mget(*keys, &blk)
+        options = (keys.pop if keys.last.is_a? Hash) || {}
+        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)
+          else
+            super(*keys.map { |key| interpolate(key) }, &blk)
+          end
+        end
+      end
+
+      def expire(key, ttl)
+        namespace(key) { |k| super(k, ttl) }
+      end
+
+      def hdel(key, *fields)
+        namespace(key) { |k| super(k, *fields) }
+      end
+
+      def hget(key, field)
+        namespace(key) { |k| super(k, field) }
+      end
+
+      def hgetall(key)
+        namespace(key) { |k| super(k) }
+      end
+
+      def hexists(key, field)
+        namespace(key) { |k| super(k, field) }
+      end
+
+      def hincrby(key, field, increment)
+        namespace(key) { |k| super(k, field, increment) }
+      end
+
+      def hincrbyfloat(key, field, increment)
+        namespace(key) { |k| super(k, field, increment) }
+      end
+
+      def hkeys(key)
+        namespace(key) { |k| super(k) }
+      end
+
+      def hlen(key)
+        namespace(key) { |k| super(k) }
+      end
+
+      def hmget(key, *fields, &blk)
+        namespace(key) { |k| super(k, *fields, &blk) }
+      end
+
+      def hmset(key, *attrs)
+        namespace(key) { |k| super(k, *attrs) }
+      end
+
+      def hset(key, *args)
+        namespace(key) { |k| super(k, *args) }
+      end
+
+      def hsetnx(key, field, val)
+        namespace(key) { |k| super(k, field, val) }
+      end
+
+      def hvals(key)
+        namespace(key) { |k| super(k) }
+      end
+
+      def hscan(key, *args)
+        namespace(key) { |k| super(k, *args) }
+      end
+
+      def hscan_each(key, *args)
+        namespace(key) { |k| super(k, *args) }
+      end
+
+      def zincrby(key, increment, member)
+        namespace(key) { |k| super(k, increment, member) }
+      end
+
+      def zscore(key, member)
+        namespace(key) { |k| super(k, member) }
+      end
+
+      def zadd(key, *args)
+        namespace(key) { |k| super(k, *args) }
+      end
+
+      def zrem(key, member)
+        namespace(key) { |k| super(k, member) }
+      end
+
+      if respond_to?(:ruby2_keywords, true)
+        ruby2_keywords :set, :setex, :setnx, :hscan, :hscan_each
+      end
+
+      def to_s
+        if namespace_str
+          "#{super} with namespace #{namespace_str}"
+        else
+          super
+        end
+      end
+
+      def flushdb
+        return super unless namespace_str
+        keys.each_slice(FLUSHDB_BATCH_SIZE) { |key_slice| del(*key_slice) }
+      end
+
+      def with_namespace(ns)
+        old_ns = @namespace
+        @namespace = ns
+        yield self
+      ensure
+        @namespace = old_ns
+      end
+
+      private
+        def namespace(key)
+          yield interpolate(key)
+        end
+
+        def namespace_str
+          @namespace.is_a?(Proc) ? @namespace.call : @namespace
+        end
+
+        def interpolate(key)
+          return key unless namespace_str
+          key.match(namespace_regexp) ? key : "#{namespace_str}:#{key}"
+        end
+
+        def strip_namespace(key)
+          return key unless namespace_str
+          key.gsub namespace_regexp, ""
+        end
+
+        def namespace_regexp
+          @namespace_regexps ||= {}
+          @namespace_regexps[namespace_str] ||= %r{^#{namespace_str}\:}
+        end
+    end
+  end
+end

data/lib/redis/store/redis_version.rb

@@ -0,0 +1,13 @@
+class Redis
+  class Store < self
+    module RedisVersion
+      def redis_version
+        info('server')['redis_version']
+      end
+
+      def supports_redis_version?(version)
+        (redis_version.split(".").map(&:to_i) <=> version.split(".").map(&:to_i)) >= 0
+      end
+    end
+  end
+end

data/lib/redis/store/serialization.rb

@@ -0,0 +1,67 @@
+class Redis
+  class Store < self
+    module Serialization
+      def set(key, value, options = nil)
+        _marshal(value, options) { |v| super encode(key), encode(v), options }
+      end
+
+      def setnx(key, value, options = nil)
+        _marshal(value, options) { |v| super encode(key), encode(v), options }
+      end
+
+      def setex(key, expiry, value, options = nil)
+        _marshal(value, options) { |v| super encode(key), expiry, encode(v), options }
+      end
+
+      def get(key, options = nil)
+        _unmarshal super(key), options
+      end
+
+      def mget(*keys, &blk)
+        options = keys.pop if keys.last.is_a?(Hash)
+        super(*keys) do |reply|
+          reply.map! { |value| _unmarshal value, options }
+          blk ? blk.call(reply) : reply
+        end
+      end
+
+      def mset(*args)
+        options = args.pop if args.length.odd?
+        updates = []
+        args.each_slice(2) do |(key, value)|
+          updates << encode(key)
+          _marshal(value, options) { |v| updates << encode(v) }
+        end
+        super(*updates)
+      end
+
+      private
+        def _marshal(val, options)
+          yield marshal?(options) ? @serializer.dump(val) : val
+        end
+
+        def _unmarshal(val, options)
+          unmarshal?(val, options) ? @serializer.load(val) : val
+        end
+
+        def marshal?(options)
+          !(options && options[:raw])
+        end
+
+        def unmarshal?(result, options)
+          result && result.size > 0 && marshal?(options)
+        end
+
+        if defined?(Encoding)
+          def encode(string)
+            key = string.to_s.dup
+            key.force_encoding(Encoding::BINARY)
+          end
+        else
+          def encode(string)
+            string
+          end
+        end
+    end
+  end
+end

data/lib/redis/store/ttl.rb

@@ -0,0 +1,47 @@
+class Redis
+  class Store < self
+    module Ttl
+      def set(key, value, options = nil)
+        if ttl = expires_in(options)
+          setex(key, ttl.to_i, value, :raw => true)
+        else
+          super(key, value, options)
+        end
+      end
+
+      def setnx(key, value, options = nil)
+        if ttl = expires_in(options)
+          setnx_with_expire(key, value, ttl.to_i, options)
+        else
+          super(key, value)
+        end
+      end
+
+      protected
+        def setnx_with_expire(key, value, ttl, options = {})
+          with_multi_or_pipelined(options) do |transaction|
+            if transaction.is_a?(Redis::Store) # for redis < 4.6
+              setnx(key, value, :raw => true)
+              expire(key, ttl)
+            else
+              transaction.setnx(key, value)
+              transaction.expire(key, ttl)
+            end
+          end
+        end
+
+      private
+        def expires_in(options)
+          if options
+            # Rack::Session           Merb                    Rails/Sinatra
+            options[:expire_after] || options[:expires_in] || options[:expire_in]
+          end
+        end
+
+        def with_multi_or_pipelined(options, &block)
+          return pipelined(&block) if options.key?(:cluster) || options[:avoid_multi_commands]
+          multi(&block)
+        end
+    end
+  end
+end

data/lib/redis/store/version.rb

@@ -0,0 +1,13 @@
+class Redis
+  class Store < self
+    # Official version + `.x`
+    VERSION = '1.9.2.1'
+
+    def self.redis_client_defined?
+      # Doesn't work if declared as constant
+      # due to unpredictable gem loading order
+      # https://github.com/redis-rb/redis-client
+      defined?(::RedisClient::VERSION)
+    end
+  end
+end