redis-store 1.0.0.1 → 1.1.0.rc

data/lib/cache/merb/redis_store.rb

@@ -1,79 +0,0 @@
-module Merb
-  module Cache
-    class RedisStore < AbstractStore
-      # Instantiate the store.
-      #
-      # Example:
-      #   RedisStore.new
-      #     # => host: localhost,   port: 6379,  db: 0
-      #
-      #   RedisStore.new :servers => ["example.com"]
-      #     # => host: example.com, port: 6379,  db: 0
-      #
-      #   RedisStore.new :servers => ["example.com:23682"]
-      #     # => host: example.com, port: 23682, db: 0
-      #
-      #   RedisStore.new :servers => ["example.com:23682/1"]
-      #     # => host: example.com, port: 23682, db: 1
-      #
-      #   RedisStore.new :servers => ["example.com:23682/1/theplaylist"]
-      #     # => host: example.com, port: 23682, db: 1, namespace: theplaylist
-      #
-      #   RedisStore.new :servers => ["localhost:6379/0", "localhost:6380/0"]
-      #     # => instantiate a cluster
-      def initialize(config = { })
-        @data = Redis::Factory.create config[:servers]
-      end
-
-      def writable?(key, parameters = {}, conditions = {})
-        true
-      end
-
-      def read(key, parameters = {}, conditions = {})
-        @data.get normalize(key, parameters), conditions
-      end
-
-      def write(key, data = nil, parameters = {}, conditions = {})
-        if writable?(key, parameters, conditions)
-          method = conditions && conditions[:unless_exist] ? :setnx : :set
-          @data.send method, normalize(key, parameters), data, conditions
-        end
-      end
-
-      def write_all(key, data = nil, parameters = {}, conditions = {})
-        write key, data, parameters, conditions
-      end
-
-      def fetch(key, parameters = {}, conditions = {}, &blk)
-        (data = read(key, parameters)) || block_given? && begin
-          data = yield
-          write(key, data, parameters, conditions)
-        end
-        data || nil
-      end
-      
-      def exists?(key, parameters = {})
-        @data.exists normalize(key, parameters)
-      end
-
-      def delete(key, parameters = {})
-        @data.del normalize(key, parameters)
-      end
-
-      def delete_all
-        @data.flushdb
-      end
-
-      def delete_all!
-        delete_all
-      end
-
-      private
-        # Returns cache key calculated from base key
-        # and SHA2 hex from parameters.
-        def normalize(key, parameters = {})
-          parameters.empty? ? "#{key}" : "#{key}--#{parameters.to_sha2}"
-        end
-    end
-  end
-end

data/lib/cache/sinatra/redis_store.rb

@@ -1,131 +0,0 @@
-module Sinatra
-  module Cache
-    class << self
-      def register(app)
-        app.set :cache, RedisStore.new
-      end
-      alias_method :registered, :register
-    end
-
-    class RedisStore
-      # Instantiate the store.
-      #
-      # Example:
-      #   RedisStore.new
-      #     # => host: localhost,   port: 6379,  db: 0
-      #
-      #   RedisStore.new "example.com"
-      #     # => host: example.com, port: 6379,  db: 0
-      #
-      #   RedisStore.new "example.com:23682"
-      #     # => host: example.com, port: 23682, db: 0
-      #
-      #   RedisStore.new "example.com:23682/1"
-      #     # => host: example.com, port: 23682, db: 1
-      #
-      #   RedisStore.new "example.com:23682/1/theplaylist"
-      #     # => host: example.com, port: 23682, db: 1, namespace: theplaylist
-      #
-      #   RedisStore.new "localhost:6379/0", "localhost:6380/0"
-      #     # => instantiate a cluster
-      def initialize(*addresses)
-        @data = Redis::Factory.create addresses
-      end
-
-      def write(key, value, options = nil)
-        if options && options[:unless_exist]
-          @data.setnx key, value, options
-        else
-          @data.set key, value, options
-        end
-      end
-
-      def read(key, options = nil)
-        @data.get(key, options)
-      end
-
-      def delete(key, options = nil)
-        @data.del key
-      end
-
-      def exist?(key, options = nil)
-        @data.exists key
-      end
-
-      # Increment a key in the store.
-      #
-      # If the key doesn't exist it will be initialized on 0.
-      # If the key exist but it isn't a Fixnum it will be initialized on 0.
-      #
-      # Example:
-      #   We have two objects in cache:
-      #     counter # => 23
-      #     rabbit  # => #<Rabbit:0x5eee6c>
-      #
-      #   cache.increment "counter"
-      #   cache.read "counter", :raw => true      # => "24"
-      #
-      #   cache.increment "counter", 6
-      #   cache.read "counter", :raw => true      # => "30"
-      #
-      #   cache.increment "a counter"
-      #   cache.read "a counter", :raw => true    # => "1"
-      #
-      #   cache.increment "rabbit"
-      #   cache.read "rabbit", :raw => true       # => "1"
-      def increment(key, amount = 1)
-        @data.incrby key, amount
-      end
-
-      # Decrement a key in the store
-      #
-      # If the key doesn't exist it will be initialized on 0.
-      # If the key exist but it isn't a Fixnum it will be initialized on 0.
-      #
-      # Example:
-      #   We have two objects in cache:
-      #     counter # => 23
-      #     rabbit  # => #<Rabbit:0x5eee6c>
-      #
-      #   cache.decrement "counter"
-      #   cache.read "counter", :raw => true      # => "22"
-      #
-      #   cache.decrement "counter", 2
-      #   cache.read "counter", :raw => true      # => "20"
-      #
-      #   cache.decrement "a counter"
-      #   cache.read "a counter", :raw => true    # => "-1"
-      #
-      #   cache.decrement "rabbit"
-      #   cache.read "rabbit", :raw => true       # => "-1"
-      def decrement(key, amount = 1)
-        @data.decrby key, amount
-      end
-
-      # Delete objects for matched keys.
-      #
-      # Example:
-      #   cache.del_matched "rab*"
-      def delete_matched(matcher, options = nil)
-        @data.keys(matcher).each { |key| @data.del key }
-      end
-
-      def fetch(key, options = {})
-        (!options[:force] && data = read(key, options)) || block_given? && begin
-          data = yield
-          write(key, data, options)
-        end
-        data || nil
-      end
-
-      # Clear all the data from the store.
-      def clear
-        @data.flushdb
-      end
-
-      def stats
-        @data.info
-      end
-    end
-  end
-end

data/lib/i18n/backend/redis.rb

@@ -1,67 +0,0 @@
-module I18n
-  module Backend
-    class Redis
-      include Base, Flatten
-      attr_accessor :store
-
-      # Instantiate the store.
-      #
-      # Example:
-      #   RedisStore.new
-      #     # => host: localhost,   port: 6379,  db: 0
-      #
-      #   RedisStore.new "example.com"
-      #     # => host: example.com, port: 6379,  db: 0
-      #
-      #   RedisStore.new "example.com:23682"
-      #     # => host: example.com, port: 23682, db: 0
-      #
-      #   RedisStore.new "example.com:23682/1"
-      #     # => host: example.com, port: 23682, db: 1
-      #
-      #   RedisStore.new "example.com:23682/1/theplaylist"
-      #     # => host: example.com, port: 23682, db: 1, namespace: theplaylist
-      #
-      #   RedisStore.new "localhost:6379/0", "localhost:6380/0"
-      #     # => instantiate a cluster
-      def initialize(*addresses)
-        @store = ::Redis::Factory.create(addresses)
-      end
-
-      def translate(locale, key, options = {})
-        options[:resolve] ||= false
-        super locale, key, options
-      end
-
-      def store_translations(locale, data, options = {})
-        escape = options.fetch(:escape, true)
-        flatten_translations(locale, data, escape, false).each do |key, value|
-          case value
-          when Proc
-            raise "Key-value stores cannot handle procs"
-          else
-            @store.set "#{locale}.#{key}", value
-          end
-        end
-      end
-
-      def available_locales
-        locales = @store.keys.map { |k| k =~ /\./; $` }
-        locales.uniq!
-        locales.compact!
-        locales.map! { |k| k.to_sym }
-        locales
-      end
-
-      protected
-        def lookup(locale, key, scope = [], options = {})
-          key = normalize_flat_keys(locale, key, scope, options[:separator])
-          @store.get "#{locale}.#{key}"
-        end
-
-        def resolve_link(locale, key)
-          key
-        end
-    end
-  end
-end

data/lib/rack/cache/redis_entitystore.rb

@@ -1,48 +0,0 @@
-module Rack
-  module Cache
-    class EntityStore
-      class RedisBase < EntityStore
-        # The underlying ::Redis instance used to communicate with the Redis daemon.
-        attr_reader :cache
-
-        extend Rack::Utils
-
-        def open(key)
-          data = read(key)
-          data && [data]
-        end
-
-        def self.resolve(uri)
-          new ::Redis::Factory.convert_to_redis_client_options(uri.to_s)
-        end
-      end
-
-      class Redis < RedisBase
-        def initialize(server, options = {})
-          @cache = ::Redis.new server
-        end
-
-        def exist?(key)
-          cache.exists key
-        end
-
-        def read(key)
-          cache.get key
-        end
-
-        def write(body)
-          buf = StringIO.new
-          key, size = slurp(body){|part| buf.write(part) }
-          [key, size] if cache.set(key, buf.string)
-        end
-
-        def purge(key)
-          cache.del key
-          nil
-        end
-      end
-
-      REDIS = Redis
-    end
-  end
-end

data/lib/rack/cache/redis_metastore.rb

@@ -1,40 +0,0 @@
-module Rack
-  module Cache
-    class MetaStore
-      class RedisBase < MetaStore
-        extend Rack::Utils
-
-        # The Redis::Store object used to communicate with the Redis daemon.
-        attr_reader :cache
-
-        def self.resolve(uri)
-          new ::Redis::Factory.convert_to_redis_client_options(uri.to_s)
-        end
-      end
-
-      class Redis < RedisBase
-        def initialize(server, options = {})
-          options[:redis_server] ||= server
-          @cache = ::Redis::Factory.create options
-        end
-
-        def read(key)
-          key = hexdigest(key)
-          cache.get(key) || []
-        end
-
-        def write(key, entries)
-          key = hexdigest(key)
-          cache.set(key, entries)
-        end
-
-        def purge(key)
-          cache.del(hexdigest(key))
-          nil
-        end
-      end
-
-      REDIS = Redis
-    end
-  end
-end

data/lib/rack/session/merb.rb

@@ -1,32 +0,0 @@
-module Merb
-  # HACK for cyclic dependency: redis-store is required before Merb session stores
-  class Mash < Hash; end
-  class SessionContainer < Mash; class_inheritable_accessor :session_store_type end
-  class SessionStoreContainer < SessionContainer; end
-
-  class RedisSession < SessionStoreContainer
-    self.session_store_type = :redis
-  end
-
-  module RedisStore
-    def retrieve_session(session_id)
-      get("session:#{session_id}")
-    end
-
-    def store_session(session_id, data)
-      set("session:#{session_id}", data)
-    end
-
-    def delete_session(session_id)
-      delete("session:#{session_id}")
-    end    
-  end
-end
-
-module Rack
-  module Session
-    class Redis
-      include Merb::RedisStore
-    end
-  end
-end

data/lib/rack/session/redis.rb

@@ -1,88 +0,0 @@
-module Rack
-  module Session
-    class Redis < Abstract::ID
-      attr_reader :mutex, :pool
-      DEFAULT_OPTIONS = Abstract::ID::DEFAULT_OPTIONS.merge :redis_server => "redis://127.0.0.1:6379/0"
-
-      def initialize(app, options = {})
-        super
-        @mutex = Mutex.new
-        options[:redis_server] ||= @default_options[:redis_server]
-        @pool = ::Redis::Factory.create options
-      end
-
-      def generate_sid
-        loop do
-          sid = super
-          break sid unless @pool.get(sid)
-        end
-      end
-
-      def get_session(env, sid)
-        session = @pool.get(sid) if sid
-        @mutex.lock if env['rack.multithread']
-        unless sid and session
-          env['rack.errors'].puts("Session '#{sid.inspect}' not found, initializing...") if $VERBOSE and not sid.nil?
-          session = {}
-          sid = generate_sid
-          ret = @pool.set sid, session
-          raise "Session collision on '#{sid.inspect}'" unless ret
-        end
-        session.instance_variable_set('@old', {}.merge(session))
-        return [sid, session]
-      rescue Errno::ECONNREFUSED
-        warn "#{self} is unable to find server."
-        warn $!.inspect
-        return [ nil, {} ]
-      ensure
-        @mutex.unlock if env['rack.multithread']
-      end
-
-      def set_session(env, session_id, new_session, options)
-        @mutex.lock if env['rack.multithread']
-        session = @pool.get(session_id) rescue {}
-        if options[:renew] or options[:drop]
-          @pool.del session_id
-          return false if options[:drop]
-          session_id = generate_sid
-          @pool.set session_id, 0
-        end
-        old_session = new_session.instance_variable_get('@old') || {}
-        session = merge_sessions session_id, old_session, new_session, session
-        @pool.set session_id, session, options
-        return session_id
-      rescue Errno::ECONNREFUSED
-        warn "#{self} is unable to find server."
-        warn $!.inspect
-        return false
-      ensure
-        @mutex.unlock if env['rack.multithread']
-      end
-
-      def destroy_session(env, session_id, options)
-        options = { :renew => true }.update(options) unless options[:drop]
-        set_session(env, session_id, 0, options)
-      end
-
-      private
-        def merge_sessions(sid, old, new, cur=nil)
-          cur ||= {}
-          unless Hash === old and Hash === new
-            warn 'Bad old or new sessions provided.'
-            return cur
-          end
-
-          delete = old.keys - new.keys
-          warn "//@#{sid}: dropping #{delete*','}" if $DEBUG and not delete.empty?
-          delete.each{|k| cur.delete k }
-
-          update = new.keys.select{|k| new[k] != old[k] }
-          warn "//@#{sid}: updating #{update*','}" if $DEBUG and not update.empty?
-          update.each{|k| cur[k] = new[k] }
-
-          cur
-        end
-    end
-  end
-end
-