redis-store-json 3.0.0

data/redis-rack-json/test/redis/rack/version_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+describe Redis::Rack::VERSION do
+  it "must be equal to 1.4.2" do
+    Redis::Rack::VERSION.must_equal '1.4.2'
+  end
+end

data/redis-rack-json/test/test_helper.rb

@@ -0,0 +1,7 @@
+Bundler.setup
+gem 'minitest'
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'mocha/setup'
+require 'rack'
+require 'rack/session/redis'

data/redis-store-json/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+gemspec
+
+gem 'SystemTimer', :platform => :mri_18

data/redis-store-json/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 - 2011 Luca Guidi
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/redis-store-json/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler'
+Bundler.setup
+require 'rake'
+require 'bundler/gem_tasks'
+
+load 'tasks/redis.tasks.rb'
+task :default => 'redis:test:suite'

data/redis-store-json/lib/redis-store-json.rb

@@ -0,0 +1,11 @@
+require 'redis'
+require 'redis/store'
+require 'redis/factory'
+require 'redis/distributed_store'
+require 'redis/store/namespace'
+require 'redis/store/version'
+
+class Redis
+  class Store < self
+  end
+end

data/redis-store-json/lib/redis/distributed_store.rb

@@ -0,0 +1,46 @@
+require 'redis/distributed'
+
+class Redis
+  class DistributedStore < Distributed
+    @@timeout = 5
+    attr_reader :ring
+
+    def initialize(addresses, options = { })
+      nodes = addresses.map do |address|
+        ::Redis::Store.new _merge_options(address, options)
+      end
+      _extend_namespace options
+      @ring = Redis::HashRing.new nodes
+    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
+
+    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)
+      end
+  end
+end

data/redis-store-json/lib/redis/factory.rb

@@ -0,0 +1,41 @@
+require 'uri'
+
+class Redis
+  class Factory
+    def self.create(*redis_client_options)
+      redis_client_options = redis_client_options.flatten.compact.inject([]) do |result, address|
+        result << resolve(address)
+        result
+      end
+      if redis_client_options.size > 1
+        ::Redis::DistributedStore.new redis_client_options
+      else
+        ::Redis::Store.new redis_client_options.first || {}
+      end
+    end
+
+    def self.resolve(uri) #:api: private
+      if uri.is_a?(Hash)
+        options = uri.dup
+        options[:namespace] ||= options.delete(:key_prefix) # RailsSessionStore
+        options
+      else
+        uri = URI.parse(uri)
+        _, db, namespace = if uri.path
+          uri.path.split /\//
+        end
+
+        options = {
+          :host     => uri.host,
+          :port     => uri.port || 6379,
+          :password => uri.password
+        }
+
+        options[:db]        = db.to_i   if db
+        options[:namespace] = namespace if namespace
+
+        options
+      end
+    end
+  end
+end

data/redis-store-json/lib/redis/store.rb

@@ -0,0 +1,47 @@
+require 'redis/store/ttl'
+require 'redis/store/interface'
+require 'redis/store/strategy'
+
+class Redis
+  class Store < self
+    include Ttl, Interface
+
+    STRATEGIES = {
+      :marshal      => Strategy::Marshal,
+      :json         => Strategy::Json,
+      :json_session => Strategy::JsonSession,
+      :yaml         => Strategy::Yaml,
+    }.freeze
+
+    def initialize(options = { })
+      super options.delete(:redis_server)
+
+      _extend_strategy  options
+      _extend_namespace options
+    end
+
+    def reconnect
+      @client.reconnect
+    end
+
+    def to_s
+      "Redis Client connected to #{@client.host}:#{@client.port} against DB #{@client.db}"
+    end
+
+    private
+      def _extend_strategy(options)
+        strategy = options[:strategy]
+
+        unless strategy === false
+          strategy_class = STRATEGIES[strategy] || STRATEGIES[:marshal]
+          extend Strategy, strategy_class
+        end
+      end
+
+      def _extend_namespace(options)
+        @namespace = options[:namespace]
+        extend Namespace if @namespace
+      end
+  end
+end
+

data/redis-store-json/lib/redis/store/interface.rb

@@ -0,0 +1,21 @@
+class Redis
+  class Store < self
+    module Interface
+      def get(key, options = nil)
+        super(key)
+      end
+
+      def set(key, value, options = nil)
+        super(key, value)
+      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/redis-store-json/lib/redis/store/namespace.rb

@@ -0,0 +1,66 @@
+class Redis
+  class Store < self
+    module Namespace
+      def set(key, val, options = nil)
+        namespace(key) { |key| super(key, val, options) }
+      end
+
+      def setnx(key, val, options = nil)
+        namespace(key) { |key| super(key, val, options) }
+      end
+
+      def get(key, options = nil)
+        namespace(key) { |key| super(key, options) }
+      end
+
+      def exists(key)
+        namespace(key) { |key| super(key) }
+      end
+
+      def incrby(key, increment)
+        namespace(key) { |key| super(key, increment) }
+      end
+
+      def decrby(key, increment)
+        namespace(key) { |key| super(key, increment) }
+      end
+
+      def keys(pattern = "*")
+        namespace(pattern) { |pattern| super(pattern).map{|key| strip_namespace(key) } }
+      end
+
+      def del(*keys)
+        super *keys.map {|key| interpolate(key) } if keys.any?
+      end
+
+      def mget(*keys)
+        super *keys.map {|key| interpolate(key) } if keys.any?
+      end
+
+      def to_s
+        "#{super} with namespace #{@namespace}"
+      end
+
+      def flushdb
+        del *keys
+      end
+
+      private
+        def namespace(key)
+          yield interpolate(key)
+        end
+
+        def interpolate(key)
+          key.match(namespace_regexp) ? key : "#{@namespace}:#{key}"
+        end
+
+        def strip_namespace(key)
+          key.gsub namespace_regexp, ""
+        end
+
+        def namespace_regexp
+          @namespace_regexp ||= %r{^#{@namespace}\:}
+        end
+    end
+  end
+end

data/redis-store-json/lib/redis/store/strategy.rb

@@ -0,0 +1,60 @@
+require 'redis/store/strategy/json'
+require 'redis/store/strategy/json_session'
+require 'redis/store/strategy/marshal'
+require 'redis/store/strategy/yaml'
+
+class Redis
+  class Store < self
+    module Strategy
+      def set(key, value, options = nil)
+        dump(value, options) { |value| super encode(key), encode(value), options }
+      end
+
+      def setnx(key, value, options = nil)
+        dump(value, options) { |value| super encode(key), encode(value), options }
+      end
+
+      def setex(key, expiry, value, options = nil)
+        dump(value, options) { |value| super encode(key), expiry, encode(value), options }
+      end
+
+      def get(key, options = nil)
+        load super(key), options
+      end
+
+      def mget(*keys)
+        options = keys.flatten.pop if keys.flatten.last.is_a?(Hash)
+        super(*keys).map do |result|
+          load result, options
+        end
+      end
+
+      private
+        def dump(val, options)
+          yield dump?(options) ? _dump(val) : val
+        end
+
+        def load(val, options)
+          load?(val, options) ? _load(val) : val
+        end
+
+        def dump?(options)
+          !(options && options[:raw])
+        end
+
+        def load?(result, options)
+          result && result.size > 0 && dump?(options)
+        end
+
+        if defined?(Encoding)
+          def encode(string)
+            string.to_s.force_encoding(Encoding::BINARY)
+          end
+        else
+          def encode(string)
+            string
+          end
+        end
+    end
+  end
+end

data/redis-store-json/lib/redis/store/strategy/json.rb

@@ -0,0 +1,49 @@
+require 'json'
+
+class Redis
+  class Store < self
+    module Strategy
+      module Json
+        private
+          SERIALIZABLE = [String, TrueClass, FalseClass, NilClass, Numeric, Date, Time].freeze
+          MARSHAL_INDICATORS = ["\x04", "\004", "\u0004"].freeze
+
+          def _dump(object)
+            object = _marshal(object)
+            object.to_json
+          end
+
+          def _load(string)
+            object = JSON.parse(string, :symbolize_names => true)
+            _unmarshal(object)
+          end
+
+          def _marshal(object)
+            case object
+            when Hash
+              object.each { |k,v| object[k] = _marshal(v) }
+            when Array
+              object.each_with_index { |v, i| object[i] = _marshal(v) }
+            when *SERIALIZABLE
+              object
+            else
+              ::Marshal.dump(object)
+            end
+          end
+
+          def _unmarshal(object)
+            case object
+            when Hash
+              object.each { |k,v| object[k] = _unmarshal(v) }
+            when Array
+              object.each_with_index { |v, i| object[i] = _unmarshal(v) }
+            when String
+              MARSHAL_INDICATORS.any?{ |indicator| object.start_with?(indicator) } ? ::Marshal.load(object) : object
+            else
+              object
+            end
+          end
+      end
+    end
+  end
+end

data/redis-store-json/lib/redis/store/strategy/json_session.rb

@@ -0,0 +1,67 @@
+class Redis
+  class Store < self
+    module Strategy
+      module JsonSession
+
+        class Error < StandardError
+        end
+
+        class SerializationError < Redis::Store::Strategy::JsonSession::Error
+          def initialize(object)
+            super "Cannot correctly serialize object: #{object.inspect}"
+          end
+        end
+
+        private
+          SERIALIZABLE = [String, TrueClass, FalseClass, NilClass, Numeric, Date, Time, Symbol]
+          MARSHAL_INDICATORS = ["\x04", "\004", "\u0004"]
+
+          def _dump(object)
+            object = _marshal(object)
+            JSON.generate(object)
+          end
+
+          def _load(string)
+            object =
+              string.start_with?(*MARSHAL_INDICATORS) ? ::Marshal.load(string) : JSON.parse(string)
+            _unmarshal(object)
+          end
+
+          def _marshal(object)
+            case object
+            when Hash
+              marshal_hash(object)
+            when Array
+              object.each_with_index { |v, i| object[i] = _marshal(v) }
+            when Set
+              _marshal(object.to_a)
+            when String
+              object.encoding == Encoding::ASCII_8BIT ? object.to_json_raw_object : object
+            when *SERIALIZABLE
+              object
+            else
+              raise SerializationError.new(object)
+            end
+          end
+
+          def marshal_hash(object)
+            object.each { |k,v| object[k] = _marshal(v) }
+          end
+
+          def _unmarshal(object)
+            case object
+            when Hash
+              object.each { |k,v| object[k] = _unmarshal(v) }
+            when Array
+              object.each_with_index { |v, i| object[i] = _unmarshal(v) }
+            when String
+              object.start_with?(*MARSHAL_INDICATORS) ? ::Marshal.load(object) : object
+            else
+              object
+            end
+          end
+
+      end
+    end
+  end
+end