redis_selector 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in redis_selector/.gemspec
+gemspec

data/README.md

@@ -0,0 +1,79 @@
+# MockRedis
+
+A gem to make it easy to use different Redises for different things.
+
+## Getting Started
+
+RedisSelector is a module that provides the `#with_redis` method.
+
+`#with_redis` takes a string and a block, and calls the block with a
+connected Redis object. The connection is closed after the block
+exits.
+
+The string is used to indicate what logical thing you're using Redis
+for. This allows for easy addition of new Redis servers if your data
+set starts getting too big.
+
+Example:
+
+    class Competitor < ActiveRecord::Base
+      extend MockRedis
+
+      def self.top10
+        with_redis('leaderboards') do |redis|
+          redis.zrange(LEADERBOARD_KEY, 0, 9).map {|id| self.find(id)}
+        end
+      end
+    end
+
+    class BlogPostsController < ApplicationController
+
+      def create
+        # ...
+        with_redis('blog_posts') {|r| r.incr('blog_posts_created' }
+        render
+      end
+    end
+
+
+By default, both these calls will connect to the same Redis. Now,
+let's say your leaderboard data is getting really big, and it's taking
+up too much space on your one little Redis machine. You spin up a new
+one and tell `RedisSelector` about it:
+
+    RedisSelector.configure(
+      'leaderboards' => {'host' => 'big-huge-redis-box'}
+      # default is localhost for things not mentioned here
+    )
+     
+Then, Marketing goes crazy and starts posting blogs all over the
+place, and all your blog posts start taking up a ton of space.
+
+    RedisSelector.configure(
+      'leaderboards' => {'host' => 'big-huge-redis-box'}
+      'blog_posts'   => {'host' => 'other-redis-box'}
+      # default is localhost for things not mentioned here
+    )
+
+That's the only code change you have to make. Throw that in
+`config/environments/production.rb` and you're done. In development,
+you probably haven't bothered to set anything up, so everything will
+just go to localhost.
+
+You can get separation by using different Redis databases, too. For
+example, if two different models use the same Redis keys and step on
+each other, you can split them up like so:
+
+    RedisSelector.configure(
+      'model1' => {'host' => 'redis-box', 'db' => 1}
+      'model2' => {'host' => 'redis-box', 'db' => 2}
+      # default is localhost/0 for things not mentioned here
+    )
+
+Since they're in different databases, they get their own keyspaces and
+don't step on each other.
+
+## Testing
+
+`RedisSelector` supports the use of `MockRedis` in test mode. Add
+`mock_redis` to your `Gemfile`, and call `RedisSelector.mock!`.

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/lib/redis_selector/.rb

@@ -0,0 +1,5 @@
+require "redis_selector//version"
+
+module RedisSelector/
+  # Your code goes here...
+end

data/lib/redis_selector/version.rb

@@ -0,0 +1,3 @@
+module RedisSelector
+  VERSION = "0.0.1"
+end

data/lib/redis_selector.rb

@@ -0,0 +1,58 @@
+require "redis_selector/version"
+
+module RedisSelector
+  DEFAULT_REDIS = {
+    'host' => 'localhost',
+  }.freeze
+
+  class << self
+    attr_accessor :mocking
+    attr_accessor :mock_redises
+    attr_accessor :config
+  end
+  self.mock_redises ||= {}
+
+  def self.mock!
+    require 'mock_redis'
+    self.mocking = true
+  end
+
+  def self.unmock!
+    self.mocking = false
+  end
+
+  def self.configure(config)
+    self.config = config
+  end
+
+  # Rather than have one big global Redis, we let you get a Redis for
+  # a specific purpose. That way, if thing X's data set gets too
+  # large, you can point Redis.for(X) at a different redis-server
+  # instance, thus allowing for sharding based on logical data
+  # grouping.
+  #
+  # This doesn't address the problem of data migration.
+  def with_redis(what)
+    redis_selector = Module.nesting[0]
+
+    config = redis_selector.config || {}
+    redis_info = config[what] || config['default'] || DEFAULT_REDIS
+
+    redis = if redis_selector.mocking
+              # A MockRedis instance doesn't persist anywhere once we
+              # drop a reference to it, while a real Redis
+              # does. That's why we hold onto this mock like this;
+              # otherwise, repeated calls to with_redis(:foo) each get
+              # a completely empty mock.
+              redis_selector.mock_redises[redis_info['host']] ||= MockRedis.new
+            else
+              Redis.new(:host => redis_info['host'])
+            end
+
+    redis.select(redis_info['db']) if redis_info['db']
+    result = yield redis
+    result
+  ensure
+    redis.quit if redis
+  end
+end

data/redis_selector/.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "redis_selector//version"
+
+Gem::Specification.new do |s|
+  s.name        = "redis_selector/"
+  s.version     = RedisSelector/::VERSION
+  s.authors     = ["Samuel Merritt"]
+  s.email       = ["spam@andcheese.org"]
+  s.homepage    = ""
+  s.summary     = %q{TODO: Write a gem summary}
+  s.description = %q{TODO: Write a gem description}
+
+  s.rubyforge_project = "redis_selector/"
+
+  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.require_paths = ["lib"]
+end

data/redis_selector.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "redis_selector/version"
+
+Gem::Specification.new do |s|
+  s.name        = "redis_selector"
+  s.version     = RedisSelector::VERSION
+  s.authors     = ["Samuel Merritt"]
+  s.email       = ["spam@andcheese.org"]
+  s.homepage    = ""
+  s.summary     = %q{Easy way to select different Redis instances/databases based on purpose.}
+  s.description = %q{Lets you select different Redis instances/databases easily.
+    This way, you get logical grouping of different Redis datasets.
+
+    Also supports mocking in test mode (via mock_redis gem).
+  }
+
+  s.rubyforge_project = "redis_selector"
+
+  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.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: redis_selector
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Samuel Merritt
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-08 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: "Lets you select different Redis instances/databases easily.\n    This way, you get logical grouping of different Redis datasets.\n\n    Also supports mocking in test mode (via mock_redis gem).\n  "
+email: 
+- spam@andcheese.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- lib/redis_selector.rb
+- lib/redis_selector/.rb
+- lib/redis_selector/version.rb
+- redis_selector.gemspec
+- redis_selector/.gemspec
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: redis_selector
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Easy way to select different Redis instances/databases based on purpose.
+test_files: []
+