redis-classy 1.2.0 → 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 43bc9e17910f065ef35c2be995966f0714ce4ea1
+  data.tar.gz: b7499771aa9b2354c43ea346d8f3878297d66ab6
+SHA512:
+  metadata.gz: 4b7491c74284bdddc17a8f47641813d608beb0dfdd4f02890e7cd79dcb04f51ba8a207cff3784ce09d4dfc3230039db945bf95b849e4b8e605051f503395e9de
+  data.tar.gz: 1614dd0aaee898bb35b74b2ccfc13d6ff866d01e8479edcdbe7c583ea68b955a2ffadbef83f3f2a953b9fbd75712a3c857f1bb4c47923d790aec3674cf1d5cc8

data/.travis.yml

@@ -1,12 +1,9 @@
 language: ruby
+services:
+  - redis-server
 rvm:
-  - 1.8.7
-  - 1.9.2
-  - 1.9.3
-  - jruby-18mode
-  - jruby-19mode
-  - rbx-18mode
-  - rbx-19mode
+  - 2.0.0
+  - 2.1.0
+  - rbx-2
   - ruby-head
   - jruby-head
-  - ree

data/CHANGELOG.md

@@ -0,0 +1,25 @@
+## 2.0.0 2014-11-23
+
+  * New feature: `singletons` to support predefined keys
+  * New feature: `singleton` to deal with singleton data
+  * New feature: `on` as a syntactic sugar for `new`
+  * New feature: `multi`, `pipelined`, `exec` and `eval` are available as instance methods
+  * No redis commands are delegated at the class level. Always use instance methods or explicitly declare singleton.
+  * The base class `Redis::Classy` is now `RedisClassy`
+  * `Redis::Classy.db = Redis.new` is now `RedisClassy.redis = Redis.new`.
+
+## 1.1.1
+
+  * Raise exception when Redis::Classy.db is not assigned
+
+## 1.1.0
+
+  * Explicitly require all files
+
+## 1.0.1
+
+  * Relaxed version dependency on redis-namespace
+
+## 1.0.0
+
+  * Play nice with Mongoid

data/README.md

@@ -1,43 +1,61 @@
-Redis Classy
-============
+# Redis Classy
 
 [![Build Status](https://secure.travis-ci.org/kenn/redis-classy.png)](http://travis-ci.org/kenn/redis-classy)
 
-Class-style namespace prefixing for Redis.
+A very simple, class-based namespace prefixing and encapsulation for Redis. Key features include:
 
-With Redis Classy, class names become the prefix part of the Redis keys.
+- Establishes a maintainable convention by prefixing keys with the class name (e.g. `YourClass:123`)
+- Delegates all method calls to the [redis-rb](https://github.com/redis/redis-rb) within the namespace
+- Adds a better abstraction layer around Redis objects and commands
+
+Here's an example:
 
 ```ruby
-class Something < Redis::Classy
+class Timer < RedisClassy
+  def start
+    pipelined do
+      set Time.now.to_i
+      expire 120.seconds
+    end
+  end
+
+  def stop
+    del
+  end
+
+  def running?
+    !!get
+  end
 end
 
-Something.set 'foo', 'bar'      # equivalent of => redis.set 'Something:foo', 'bar'
-Something.get 'foo'             # equivalent of => redis.get 'Something:foo'
- => "bar"
+timer = Timer.new(123)
+timer.start
+timer.running?
+=> true
+
+Timer.keys
+=> ["123"]
+RedisClassy.keys
+=> ["Timer:123"]
 ```
 
-All methods are delegated to the `redis-namespace` gems.
+The Timer class above is self-contained and more readable.
 
-This library contains only 30+ lines of code, yet powerful when you need better abstraction on Redis objects to keep things organized.
+This library is made intentionally small, yet powerful when you need better abstraction on Redis objects to keep things organized.
 
-### What's new:
+### UPGRADING FROM v1
 
-* v1.2.0: Raise NoMethodError when commands are not found in redis-rb.
-* v1.1.1: Raise exception when Redis::Classy.db is not assigned
-* v1.1.0: Explicitly require all files
-* v1.0.1: Relaxed version dependency on redis-namespace
-* v1.0.0: Play nice with Mongoid
+[**An important message about upgrading from 1.x**](UPGRADING.md)
 
-Synopsis
---------
+
+## redis-rb vs redis-namespace vs redis-classy
 
 With the vanilla `redis` gem, you've been doing this:
 
 ```ruby
 redis = Redis.new
 redis.set 'foo', 'bar'
-redis.get 'foo'
- => "bar"
+redis.get 'foo'                 # => "bar"
 ```
 
 With the `redis-namespace` gem, you can add a prefix in the following manner:
@@ -45,31 +63,23 @@ With the `redis-namespace` gem, you can add a prefix in the following manner:
 ```ruby
 redis_ns = Redis::Namespace.new('ns', :redis => redis)
 redis_ns['foo'] = 'bar'         # equivalent of => redis.set 'ns:foo', 'bar'
-redis_ns['foo']                 # equivalent of => redis.get 'ns:foo'
- => "bar"
+redis_ns['foo']                 # => "bar"
 ```
 
-Now, with the `redis-classy` gem, you finally achieve a class-based encapsulation:
+Now, with the `redis-classy` gem, you finally achieve a class-based naming convention:
 
 ```ruby
-class Something < Redis::Classy
+class Something < RedisClassy
 end
 
-Something.set 'foo', 'bar'      # equivalent of => redis.set 'Something:foo', 'bar'
-Something.get 'foo'             # equivalent of => redis.get 'Something:foo'
- => "bar"
+Something.on('foo').set('bar')  # equivalent of => redis.set 'Something:foo', 'bar'
+Something.on('foo').get         # => "bar"
 
 something = Something.new('foo')
-something.set 'bar'
-something.get
- => "bar"
+something.set 'bar'             # equivalent of => redis.set 'Something:foo', 'bar'
+something.get                   # => "bar"
 ```
 
-Install
--------
-
-    gem install redis-classy
-
 Usage
 -----
 
@@ -82,77 +92,84 @@ gem 'redis-classy'
 Register the Redis server: (e.g. in `config/initializers/redis_classy.rb` for Rails)
 
 ```ruby
-Redis::Classy.db = Redis.new(:host => 'localhost')
+RedisClassy.redis = Redis.current
 ```
 
-Now you can write models that inherit `Redis::Classy`, automatically prefixing keys with its class name.
-You can use any Redis commands on the class, as they are eventually passed to the `redis` gem.
+Create a class that inherits RedisClassy. (e.g. in `app/redis/cache.rb` for Rails, for auto- and eager-loading)
 
 ```ruby
-class UniqueUser < Redis::Classy
-  def self.nuke
-    self.keys.each{|key| self.del(key) }
+class Cache < RedisClassy
+  def put(content)
+    pipelined do
+      set content
+      expire 5.seconds
+    end
   end
 end
 
-UniqueUser.sadd '2011-02-28', '123'
-UniqueUser.sadd '2011-02-28', '456'
-UniqueUser.sadd '2011-03-01', '789'
+cache = Cache.new(123)
+cache.put "This tape will self-destruct in five seconds. Good luck."
+```
+
+Since the `on` method is added as a syntactic sugar for `new`, you can also run a command in one shot as well:
+
+```ruby
+Cache.on(123).persist
+```
+
+For convenience, singleton and predefined static keys are also supported.
+
+```ruby
+class Counter < RedisClassy
+  singleton
+end
+
+Counter.incr    # 'Counter:singleton' => '1'
+Counter.incr    # 'Counter:singleton' => '2'
+Counter.get     # => '2'
+```
 
-UniqueUser.smembers '2011-02-28'
- => ["123", "456"]
+``` ruby
+class Stats < RedisClassy
+  singletons :median, :average
+end
 
-UniqueUser.keys
- => ["2011-02-28", "2011-03-01"]
+ages = [21,22,24,28,30]
 
-UniqueUser.nuke
-UniqueUser.keys
- => []
+Stats.median.set  ages[ages.size/2]           # 'Stats:median'  => '24'
+Stats.average.set ages.inject(:+)/ages.size   # 'Stats:average' => '25'
+Stats.median.get    # => '24'
+Stats.average.get   # => '25'
 ```
 
-In most cases you may be just fine with class methods, but by creating an instance with a key, even further binding is possible.
+Finally, you can also pass an arbitrary object that responds to `id` as a key. This is useful when used in combination with ActiveRecord, etc.
 
 ```ruby
-class Counter < Redis::Classy
-  def initialize(object)
-    super("#{object.class.name}:#{object.id}")
-  end
+class Lock < RedisClassy
 end
 
 class Room < ActiveRecord::Base
 end
 
-@room = Room.create
+room = Room.create
 
-counter = Counter.new(@room)
-counter.key
- => "Room:123"
-
-counter.incr
-counter.incr
-counter.get
- => "2"
+lock = Lock.new(room)
 ```
 
-You also have access to the non-namespaced, raw Redis instance via `Redis::Classy`.
+When you need an access to the non-namespaced, raw Redis keys, it's available as `RedisClass.keys`. Keep in mind that this method is very slow at O(N) computational complexity and potentially hazardous when you have many keys. [Read the details](http://redis.io/commands/keys).
 
 ```ruby
-Redis::Classy.keys
- => ["UniqueUser:2011-02-28", "UniqueUser:2011-03-01", "Counter:Room:123"]
-
-Redis::Classy.keys 'UniqueUser:*'
- => ["UniqueUser:2011-02-28", "UniqueUser:2011-03-01"]
+RedisClassy.keys
+=> ["Stats:median", "Stats:average", "Counter"]
 
-Redis::Classy.multi do
-  UniqueUser.sadd '2011-02-28', '123'
-  UniqueUser.sadd '2011-02-28', '456'
-end
+RedisClassy.keys 'Stats:*'
+=> ["Stats:median", "Stats:average"]
 ```
 
-Since the `db` attribute is a class instance variable, you can dynamically assign different databases for each class.
+Since the `redis` attribute is a class instance variable, you can dynamically assign different databases for each class, without affecting other classes.
 
 ```ruby
-UniqueUser.db = Redis::Namespace.new('UniqueUser', :redis => Redis.new(:host => 'another.host'))
+Cache.redis = Redis::Namespace.new('Cache', redis: Redis.new(host: 'another.host'))
 ```
 
 Unicorn support
@@ -162,11 +179,11 @@ If you run fork-based app servers such as **Unicorn** or **Passenger**, you need
 
 ```ruby
 after_fork do
-  Redis::Classy.db.client.reconnect
+  RedisClassy.redis.client.reconnect
 end
 ```
 
-Note that since Redis Classy assigns a namespaced Redis instance upon the inheritance event of each subclass (`class Something < Redis::Classy`), reconnecting the master (non-namespaced) connection that is referenced from all subclasses should probably be the safest and the most efficient way to survive a forking event.
+Note that since Redis Classy assigns a namespaced Redis instance upon the inheritance event of each subclass (`class Something < RedisClassy`), reconnecting the master (non-namespaced) connection that is referenced from all subclasses should probably be the safest and the most efficient way to survive a forking event.
 
 Reference
 ---------

data/UPGRADING.md

@@ -0,0 +1,10 @@
+# Upgrading from 1.x
+
+`redis-classy` 2.0 has brought quite a few changes. Please read these points carefully.
+
+Please post any implications we may have missed as a GitHub Issue or Pull Request.
+
+* No redis commands are delegated at the class level. Always use instance methods or explicitly declare singleton.
+  * `Something.set 'key', 'value'` is now `Something.on('key').set('value')`
+* The base class `Redis::Classy` is now `RedisClassy`.
+* `Redis::Classy.db = Redis.new` is now `RedisClassy.redis = Redis.new`.

data/lib/redis-classy.rb

@@ -1,3 +1,3 @@
 require 'redis-namespace'
-require 'redis/classy'
-require 'redis/classy/version'
+require 'redis_classy'
+require 'redis_classy/version'

data/lib/redis_classy/version.rb

@@ -0,0 +1,3 @@
+class RedisClassy
+  VERSION = '2.0.0'
+end

data/lib/redis_classy.rb

@@ -0,0 +1,75 @@
+class RedisClassy
+  class << self
+    attr_accessor :redis
+
+    def inherited(subclass)
+      raise Error.new('RedisClassy.redis is not assigned') unless RedisClassy.redis
+      subclass.redis = Redis::Namespace.new(subclass.name, redis: RedisClassy.redis)
+    end
+
+    def singletons(*args)
+      args.each do |key|
+        define_singleton_method(key) do
+          new key
+        end
+      end
+    end
+
+    def singleton
+      @singleton = true
+    end
+
+    def keys(pattern = nil)
+      @redis.keys(pattern || '*')
+    end
+
+    def on(key)
+      new(key)
+    end
+
+    def method_missing(command, *args, &block)
+      if @singleton
+        new('singleton').send(command, *args, &block)
+      else
+        super
+      end
+    end
+  end
+
+  # Instance methods
+
+  attr_accessor :key, :redis, :object
+
+  def initialize(object)
+    @redis = self.class.redis
+    @object = object
+
+    case object
+    when String, Symbol, Integer
+      @key = object.to_s
+    else
+      if object.respond_to?(:id)
+        @key = object.id.to_s
+      else
+        raise ArgumentError, 'object must be a string, symbol, integer or respond to :id method'
+      end
+    end
+  end
+
+  KEYLESS_COMMANDS = [:multi, :pipelined, :exec, :eval]
+
+  def method_missing(command, *args, &block)
+    if @redis.respond_to?(command)
+      case command
+      when *KEYLESS_COMMANDS
+        @redis.send(command, *args, &block)
+      else
+        @redis.send(command, @key, *args, &block)
+      end
+    else
+      super
+    end
+  end
+
+  Error = Class.new(StandardError)
+end

data/redis-classy.gemspec

@@ -1,5 +1,5 @@
 # -*- encoding: utf-8 -*-
-require File.expand_path('../lib/redis/classy/version', __FILE__)
+require File.expand_path('../lib/redis_classy/version', __FILE__)
 
 Gem::Specification.new do |gem|
   gem.authors       = ["Kenn Ejima"]
@@ -13,7 +13,7 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "redis-classy"
   gem.require_paths = ["lib"]
-  gem.version       = Redis::Classy::VERSION
+  gem.version       = RedisClassy::VERSION
 
   gem.add_runtime_dependency "redis-namespace", "~> 1.0"
   gem.add_development_dependency "rspec"

data/spec/redis_classy_spec.rb

@@ -1,65 +1,75 @@
 require 'spec_helper'
 
-class Something < Redis::Classy
+class Something < RedisClassy
 end
 
-class Another < Something
-end
+describe RedisClassy do
+  before do
+    RedisClassy.redis.flushdb
+  end
 
-module Deep
-  class Klass < Another
+  after(:all) do
+    RedisClassy.redis.flushdb
+    RedisClassy.redis.quit
   end
-end
 
-describe Redis::Classy do
-  before do
-    Redis::Classy.flushdb
+  it 'stores redis or redis-namespace' do
+    expect(RedisClassy.redis.is_a?(Redis)).to be_truthy
+    expect(RedisClassy.redis.is_a?(Redis::Namespace)).to be_falsy
+    expect(Something.redis.is_a?(Redis)).to be_falsy
+    expect(Something.redis.is_a?(Redis::Namespace)).to be_truthy
   end
 
-  after(:all) do
-    Redis::Classy.flushdb
-    Redis::Classy.quit
+  it 'gets keys' do
+    Something.on(:foo).set('bar')
+    expect(Something.keys).to eq(['foo'])
+    expect(RedisClassy.keys).to eq(['Something:foo'])
   end
 
   it 'prepends class name to the key' do
-    Something.set('foo', 'bar')
-    Something.keys.should == ['foo']
-    Redis::Classy.keys.should include 'Something:foo'
+    class Another < Something
+    end
 
-    Another.set('foo', 'bar')
-    Another.keys.should == ['foo']
-    Redis::Classy.keys.should include 'Another:foo'
+    module Deep
+      class Klass < Another
+      end
+    end
 
-    Deep::Klass.set('foo', 'bar')
-    Deep::Klass.keys.should == ['foo']
-    Redis::Classy.keys.should include 'Deep::Klass:foo'
-  end
+    Something.on(:foo).set('bar')
+    expect(Something.on(:foo).keys).to eq(['foo'])
+    expect(RedisClassy.keys.size).to eq(1)
+    expect(RedisClassy.keys).to include 'Something:foo'
+
+    Another.on(:foo).set('bar')
+    expect(Another.on(:foo).keys).to eq(['foo'])
+    expect(RedisClassy.keys.size).to eq(2)
+    expect(RedisClassy.keys).to include 'Another:foo'
 
-  it 'delegates to class methods' do
-    Something.get('foo').should == nil
-    Something.set('foo', 'bar')
-    Something.get('foo').should == 'bar'
+    Deep::Klass.on(:foo).set('bar')
+    expect(Deep::Klass.on(:foo).keys).to eq(['foo'])
+    expect(RedisClassy.keys.size).to eq(3)
+    expect(RedisClassy.keys).to include 'Deep::Klass:foo'
   end
 
   it 'delegates instance methods with the key binding' do
     something = Something.new('foo')
 
-    something.get.should == nil
+    expect(something.get).to eq(nil)
     something.set('bar')
-    something.get.should == 'bar'
-    Something.get('foo').should == 'bar'
+    expect(something.get).to eq('bar')
+    expect(Something.on(:foo).get).to eq('bar')
   end
 
   it 'handles multi block' do
     something = Something.new('foo')
 
-    Redis::Classy.multi do
+    something.multi do
       something.sadd 1
       something.sadd 2
       something.sadd 3
     end
 
-    something.smembers.should == ['1','2','3']
+    expect(something.smembers).to eq(['1','2','3'])
   end
 
   it 'handles method_missing' do
@@ -71,20 +81,26 @@ describe Redis::Classy do
     expect { something.bogus }.to raise_error(NoMethodError)
   end
 
-  it 'should battle against mongoid' do
-    # Emulate notorious Mongoid::Extensions::Object::Conversions
-    class Object
-      def self.get(value)
-        value
-      end
+  it 'handles singleton key' do
+    class Counter < RedisClassy
+      singleton
     end
 
-    # This would have returned "foo" instead of nil, unless we explicitly defined
-    # class methods from Redis::Namespace::COMMANDS
-    Something.get('foo').should == nil
+    Counter.incr
+    expect(Counter.get).to eq('1')
+    Counter.incr
+    expect(Counter.get).to eq('2')
+  end
 
-    class << Object
-      remove_method :get
+  it 'handles predefined keys' do
+    class Stats < RedisClassy
+      singletons :median, :average
     end
+
+    ages = [21,22,24,28,30]
+    Stats.median.set  ages[ages.size/2]
+    Stats.average.set ages.inject(:+)/ages.size
+    expect(Stats.median.get).to eq('24')
+    expect(Stats.average.get).to eq('25')
   end
 end

data/spec/spec_helper.rb

@@ -6,8 +6,8 @@ require 'redis-classy'
 
 RSpec.configure do |config|
   # Use database 15 for testing so we don't accidentally step on you real data.
-  Redis::Classy.db = Redis.new(:db => 15)
-  unless Redis::Classy.keys.empty?
+  RedisClassy.redis = Redis.new(db: 15)
+  unless RedisClassy.keys.empty?
     puts '[ERROR]: Redis database 15 not empty! If you are sure, run "rake flushdb" beforehand.'
     exit!
   end

metadata

@@ -1,78 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: redis-classy
 version: !ruby/object:Gem::Version
-  version: 1.2.0
-  prerelease: 
+  version: 2.0.0
 platform: ruby
 authors:
 - Kenn Ejima
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-09 00:00:00.000000000 Z
+date: 2014-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-namespace
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Class-style namespace prefixing for Redis
@@ -82,44 +73,44 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
+- UPGRADING.md
 - lib/redis-classy.rb
-- lib/redis/classy.rb
-- lib/redis/classy/version.rb
+- lib/redis_classy.rb
+- lib/redis_classy/version.rb
 - redis-classy.gemspec
 - spec/redis_classy_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/kenn/redis-classy
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.19
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Class-style namespace prefixing for Redis
 test_files:
 - spec/redis_classy_spec.rb
 - spec/spec_helper.rb
-has_rdoc: 

data/lib/redis/classy/version.rb

@@ -1,5 +0,0 @@
-class Redis
-  class Classy
-    VERSION = '1.2.0'
-  end
-end

data/lib/redis/classy.rb

@@ -1,37 +0,0 @@
-class Redis
-  class Classy
-    class << self
-      attr_accessor :db
-
-      def inherited(subclass)
-        raise 'Redis::Classy.db is not assigned' unless Redis::Classy.db
-        subclass.db = Redis::Namespace.new(subclass.name, :redis => Redis::Classy.db)
-      end
-
-      def delegatables
-        @delegatables ||= Redis::Classy.db.class.instance_methods(false).map(&:to_sym) # ruby1.8 returns strings
-      end
-
-      def method_missing(command, *args, &block)
-        return super unless delegatables.include?(command)
-        db.send(command, *args, &block)
-      end
-
-      Redis::Namespace::COMMANDS.keys.each do |command|
-        define_method(command) do |*args, &block|
-          db.send(command, *args, &block)
-        end
-      end
-    end
-
-    attr_accessor :key
-
-    def initialize(key)
-      @key = key
-    end
-
-    def method_missing(command, *args, &block)
-      self.class.send(command, @key, *args, &block)
-    end
-  end
-end