redised 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,15 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+gem 'redis', '~>2'
+gem 'redis-namespace'
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "mocha"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.8.3"
+end

data/Gemfile.lock

@@ -0,0 +1,31 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.8.3)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.6.5)
+    metaclass (0.0.1)
+    mocha (0.10.3)
+      metaclass (~> 0.0.1)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    redis (2.2.2)
+    redis-namespace (1.1.0)
+      redis (< 3.0.0)
+    shoulda (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.8.3)
+  mocha
+  redis (~> 2)
+  redis-namespace
+  shoulda

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Aaron Quint, Paperless Inc.
+
+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/README.rdoc

@@ -0,0 +1,89 @@
+= redised
+
+Redised provides a simple module for establishing reusable class level namespaced redis connections
+in your vanilla Ruby classes.
+
+== Why?
+
+We use redis a lot throughout our apps. This pattern of having a class level `redis` method
+thats already namespaced and connected to a specific server via a config has served us well. 
+It has allowed us to split different usages across different namespaces and eventually
+different hosts/servers.
+
+== Usage
+
+You can include Redised as a module in your class.
+
+    class MyRedisClass
+      include Redised
+    end
+
+This now gives you the power to assign the url of the redis server you want to connect to
+as a string:
+
+    MyRedisClass.redis = 'localhost:6739:1/myredisclass' # hostname:port:db/namespace
+    # also accepts a Redis or Redis::Namespace object
+
+This gets a little easier and more powerful when you setup a YAML config:
+
+    # in config/redis.yml 
+    ---
+    mynamespace:
+      development: localhost:6379
+      production: redis01:6379/mynamespace
+    othernamespace:
+      development: localhost:6379
+      production: redis01:6379/othernamespace
+
+You can tell redised where this config lives:
+
+    Redised.redised_config_path = File.join(Rails.root, 'config', 'redis.yml')
+
+And what the 'env' is (will try to pull from RACK_ENV and RAILS_ENV):
+
+    Redised.redised_env = Rails.env #=> 'production'
+
+Then in your class you tell it what namespace config this class points to:
+
+    class MyRedisClass
+      include Redised
+
+      redised_namespace 'mynamespace'
+
+    end
+
+It will now automatically load the correct redis connection for your namespace/env:
+
+    MyRedisClass.redis #=> #<Redis::Namespace ..>
+    MyRedisClass.redis.client.host #=> 'redis01'
+    MyRedisClass.namespace #=> 'mynamespace'
+
+The implementation of the `self.redis` method is very close to the `Resque.redis` method and is
+actually a drop in replacement (if you want to load your connection settings from a config). Our
+`config/initializers/resque.rb` looks like:
+
+      module Resque
+        include Redised
+        extend self
+
+        redised_namespace 'paperless'
+      end
+
+== Acknowledgments
+
+The original parsing of URL idea came from @defunkt/resque.
+
+== Contributing to redised
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2012 Aaron Quint, Paperless Inc. See LICENSE.txt for further details.
+

data/Rakefile

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require './lib/redised'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "redised"
+  gem.version = Redised::VERSION
+  gem.homepage = "http://github.com/paperlesspost/redised"
+  gem.license = "MIT"
+  gem.summary = %Q{a simple module that allows you to setup your class or module with a redis connection}
+  gem.description = %Q{redised provides a single module `Redised` that when included in your class provides a self.redis= and self.redis methods. It also has the ability to load the urls from a YAML config file}
+  gem.email = "aaron@quirkey.com"
+  gem.authors = ["Aaron Quint"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "redised #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/redised.rb

@@ -0,0 +1,115 @@
+require 'redis/namespace'
+# Redised allows for the common patter of module access to redis, when included
+# a .redis and .redis= method are provided
+module Redised
+  VERSION = '0.1.0'
+
+  # Get a reusable connection based on a set of params. The
+  # params are the same as the options you pass to `Redis.new`
+  #
+  # This ensures that an app doesnt try to open multiple connections
+  # to the same redis server.
+  def self.redis_connection(params)
+    @_redis_connections ||= {}
+    @_redis_connections[params] ||= Redis.new(params)
+  end
+
+  # Load/parse the YAML config setup at `redised_config_path`.
+  # If no config is setup, returns nil
+  #
+  # Configs are in the format:
+  #
+  #     ---
+  #     namespace:
+  #       env: url
+  #
+  def self.redised_config
+    if @_redised_config_path
+      @_redised_config ||= YAML.load_file(@_redised_config_path)
+    end
+  end
+
+  # Return the config path for the YAML config.
+  def self.redised_config_path
+    @_redised_config_path
+  end
+
+  # Set the config path to load from.
+  def self.redised_config_path=(new_path)
+    @_redised_config_path = new_path
+    @_redised_config = nil
+  end
+
+  def self.redised_env
+    @_redised_env ||= ENV['RAILS_ENV'] || ENV['RACK_ENV'] || nil
+  end
+
+  def self.redised_env=(new_env)
+    @_redised_env = new_env
+    @_redised_config = nil
+  end
+
+  def self.included(klass)
+
+    klass.module_eval do
+
+      # Accepts:
+      #   1. A 'hostname:port' string
+      #   2. A 'hostname:port:db' string (to select the Redis db)
+      #   3. A 'hostname:port/namespace' string (to set the Redis namespace)
+      #   4. A redis URL string 'redis://host:port'
+      #   5. An instance of `Redis`, `Redis::Client`, `Redis::DistRedis`,
+      #      or `Redis::Namespace`.
+      def self.redis=(server)
+        if server.respond_to? :split
+
+          if server =~ /redis\:\/\//
+            conn = ::Redised.redis_connection(:url => server)
+          else
+            server, namespace = server.split('/', 2)
+            host, port, db = server.split(':')
+            conn = ::Redised.redis_connection(:host => host, :port => port,
+                              :thread_safe => true, :db => db)
+          end
+
+          @_redis = namespace ? Redis::Namespace.new(namespace, :redis => conn) : conn
+        else
+          @_redis = server
+        end
+      end
+
+      def self.redised_namespace(new_name = nil)
+        if new_name
+          @_namespace = new_name
+          @_redis = nil
+        else
+          @_namespace
+        end
+      end
+
+      # Returns the current Redis connection. If none has been created, will
+      # create a new one.
+      def self.redis
+        return @_redis if @_redis
+        if ::Redised.redised_config
+          self.redis = if redised_namespace
+            ::Redised.redised_config[redised_namespace][::Redised.redised_env]
+          else
+            ::Redised.redised_config[::Redis.redised_env]
+          end
+        else
+          self.redis = 'localhost:6379'
+        end
+        @_redis
+      rescue NoMethodError => e
+        raise("There was a problem setting up your redis for redised_namespace #{redised_namespace} (from file #{@_redised_config_path}): #{e}")
+      end
+
+      def redis
+        self.class.redis
+      end
+    end
+
+  end
+
+end

data/redised.gemspec

@@ -0,0 +1,65 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "redised"
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Aaron Quint"]
+  s.date = "2012-02-06"
+  s.description = "redised provides a single module `Redised` that when included in your class provides a self.redis= and self.redis methods. It also has the ability to load the urls from a YAML config file"
+  s.email = "aaron@quirkey.com"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "lib/redised.rb",
+    "redised.gemspec",
+    "test/env_redised_config.yml",
+    "test/helper.rb",
+    "test/test_redised.rb"
+  ]
+  s.homepage = "http://github.com/paperlesspost/redised"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.10"
+  s.summary = "a simple module that allows you to setup your class or module with a redis connection"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<redis>, ["~> 2"])
+      s.add_runtime_dependency(%q<redis-namespace>, [">= 0"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
+    else
+      s.add_dependency(%q<redis>, ["~> 2"])
+      s.add_dependency(%q<redis-namespace>, [">= 0"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+    end
+  else
+    s.add_dependency(%q<redis>, ["~> 2"])
+    s.add_dependency(%q<redis-namespace>, [">= 0"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+  end
+end
+

data/test/env_redised_config.yml

@@ -0,0 +1,3 @@
+---
+mynamespace:
+  production: localhost:6739/mynamespace

data/test/helper.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'redised'
+
+class Test::Unit::TestCase
+end

data/test/test_redised.rb

@@ -0,0 +1,54 @@
+require 'helper'
+
+class TestRedised < Test::Unit::TestCase
+
+  class RedisedClass
+    include Redised
+
+    redised_namespace 'mynamespace'
+  end
+
+  class OtherRedisedClass
+    include Redised
+  end
+
+  context "Redised" do
+    setup do
+      @env_config_path = File.join(File.dirname(__FILE__), 'env_redised_config.yml')
+    end
+
+    should "be able to assign the redised_config_path" do
+      Redised.redised_config_path = @env_config_path
+      assert_equal @env_config_path, Redised.redised_config_path
+      assert Redised.redised_config['mynamespace']
+    end
+
+    should "pull default env from ENV" do
+      ENV['RAILS_ENV'] = 'production'
+      assert_equal 'production', Redised.redised_env
+    end
+
+    should "allow for setting the env" do
+      Redised.redised_env = 'dev'
+      assert_equal 'dev', Redised.redised_env
+    end
+
+    should "have class level redis connection" do
+      Redised.redised_config_path = @env_config_path
+      Redised.redised_env = 'production'
+      redis = RedisedClass.redis
+      assert_kind_of Redis::Namespace, redis
+    end
+
+    should "parse redis connection with namespace" do
+      RedisedClass.redis = 'localhost:5678:0/namespace'
+      redis = RedisedClass.redis
+      assert_equal 'localhost', redis.client.host
+      assert_equal 5678, redis.client.port
+      assert_equal 0, redis.client.db
+      assert_equal 'namespace', redis.namespace
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: redised
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Aaron Quint
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-06 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: &70189510863680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70189510863680
+- !ruby/object:Gem::Dependency
+  name: redis-namespace
+  requirement: &70189510862940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70189510862940
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: &70189510862180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70189510862180
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &70189510861600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70189510861600
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70189510860720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *70189510860720
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &70189510858840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+  type: :development
+  prerelease: false
+  version_requirements: *70189510858840
+description: redised provides a single module `Redised` that when included in your
+  class provides a self.redis= and self.redis methods. It also has the ability to
+  load the urls from a YAML config file
+email: aaron@quirkey.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- lib/redised.rb
+- redised.gemspec
+- test/env_redised_config.yml
+- test/helper.rb
+- test/test_redised.rb
+homepage: http://github.com/paperlesspost/redised
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 421598399054906059
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: a simple module that allows you to setup your class or module with a redis
+  connection
+test_files: []