redis_obj 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 60078190708a0aa3872d0df60a6d389ab6949117
-  data.tar.gz: c88fb3d786df0eb865cdaf30816eada0b4315c8f
+  metadata.gz: 813c912763a0a73b1930d20bfbc7a67e72723ca9
+  data.tar.gz: e3795e83b616cdb64daab0d5f8ee920ad7a8f027
 SHA512:
-  metadata.gz: 8304198906cc62aa89c17de1ee495d87c01f0f70569b548105a49195f68feb6b67c0d5d95e84dafc6dca7b770b15a1914f2a52c5bcb2dfd8ee4361d36a50dcef
-  data.tar.gz: 6d813e8d0144add088b84b744c0a6952c7d6ef717e2fe9e908190b3a48401c6663be400dc72af0449ab768b12c913975b535615b56d345ec1c3970e5518c1dc2
+  metadata.gz: 3b1ad422bc3469a8c1a2ec6220aa59ea39f58ec3f4115b71151bbf380bb99e6d4896bbf5aef324ec43a6798327d20f5f4cd16fa196695e6030df5f2fa2f098eb
+  data.tar.gz: ea491f767b9a5e669c2af5cff37177af7a4d0e9ceec5dca95c7dc9bd807be8804513c89d86f7a61967f6323753c7ff07531c6d169c13ed71800c1c464b300323

data/.travis.yml

@@ -0,0 +1,7 @@
+script: bundle exec rspec spec
+language: ruby
+rvm:
+  - 2.0.0
+  - 1.9.3
+  - jruby-19mode
+  - rbx-19mode

data/README.md

@@ -1,6 +1,16 @@
 # RedisObj
 
-TODO: Write a gem description
+[![Build Status](https://travis-ci.org/tal/redis_obj.png)](https://travis-ci.org/tal/redis_obj)
+
+This gem allows you to treat redis stores like ruby objects.
+
+    RedisObj::Set.new('myset').include?('foo')
+
+Will run the redis command
+
+    SISMEMBER myset foo
+
+So a hash key would act like a ruby hash, a set a set, and a list an array.
 
 ## Installation
 
@@ -18,7 +28,64 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+All the RedisObj wrappers have common ruby functions implemented
+
+    RedisObj::Set.new('set1').to_a
+    # => SMEMBERS set1
+
+    RedisObj::Set.new('set1') & RedisObj::Set.new('set2')
+    #=> SINTER set1 set2
+
+    RedisObj::Set.new('set1') - RedisObj::Set.new('set2')
+    # => SDIFF set1 set2
+
+You can also just call the methods staright out
+
+    RedisObj::Hash.new('hash1').mget('key','key2')
+    # => HMGET hash1 key key2
+
+### Relations
+
+You can embed redis objects into an object very easily.
+
+    class Foo
+      attr_accessor :id, :bar
+      include RedisObj::Relation
+      redis_set :baz
+    end
+
+This will add a class and instance method to the object.
+
+    foo = Foo.new
+    foo.id = 123
+    foo.baz # => RedisObj::Set.new('foo:123:baz')
+
+Class method:
+
+    Foo.redis_baz(id: 321) # => RedisObj::Set.new('foo:321:baz')
+    Foo.redis_baz(OpenStruct.new(id: 'myid')) # => RedisObj::Set.new('foo:myid:baz')
+
+You can override the namespace for all redis relations easily:
+
+    class Foo
+      attr_accessor :id, :bar
+      include RedisObj::Relation
+      store_redis_in { "foons:#{id}:#{bar}" }
+      redis_set :baz, key: 'b'
+      redis_hash :hashy, key: 'h'
+    end
+
+will allow the relations:
+
+    foo = Foo.new
+    foo.id = 123
+    foo.bar = 'mybar'
+    foo.baz # => RedisObj::Set.new('foons:123:mybar:b')
+    foo.hashy # => RedisObj::Hash.new('foons:123:mybar:h')
+
+### Examples
+
+For more information on how relations work or how to use the gem check out the [examples](https://github.com/tal/redis_obj/wiki#examples).
 
 ## Contributing
 

data/TODO.md

@@ -0,0 +1,5 @@
+* Detect if the redis client is currently pipelined, an instance of `Redis::Pipeline` and warn or error in that situation.
+* Add range support to `List#[]`
+* Optionally cache values when you pull down entire set
+* In storage methods generate a random destination key if not given
+* Allow sets and lists to interact with arrays directly for comparison actions

data/lib/redis_obj.rb

@@ -1,9 +1,12 @@
 require 'ostruct'
+require 'forwardable'
+require 'securerandom'
 
 %w{
   version
   base
   set
+  list
   sorted_set
   hash
   relations

data/lib/redis_obj/base.rb

@@ -1,4 +1,5 @@
 class RedisObj::Base
+  extend Forwardable
   attr_accessor :key, :redis
   def initialize redis, key=nil
     unless key
@@ -17,9 +18,12 @@ class RedisObj::Base
     redis.del(key)
   end
 
-  private
+  def clear
+    redis.del(key)
+  end
 
   def get_keys(keys)
+    keys = keys.flatten
     if keys.first.respond_to?(:key)
       keys.collect(&:key)
     else

data/lib/redis_obj/hash.rb

@@ -1,7 +1,10 @@
 class RedisObj::Hash < RedisObj::Base
-  def del field
+  include Enumerable
+
+  def hdel field
     redis.hdel(key,field)
   end
+  alias delete hdel
 
   def incby field, amt
     if amt.is_a?(Float)
@@ -10,60 +13,119 @@ class RedisObj::Hash < RedisObj::Base
       redis.hincrby(key,field,amt)
     end
   end
-  alias incbyfloat incby
+  alias hincrby incby
+  alias hincrbyfloat incby
+  alias hincbyfloat incby
 
+  # Increment by one
   def inc field
     incby(field,1)
   end
+  alias incr inc
 
+  # Decriment by one
   def dec field
     incby(field,-1)
   end
+  alias decr dec
 
-  def mget *fields
+  def hmget *fields
     redis.hmget(key,*fields)
   end
+  alias values_at hmget
 
-  def mset *fields
+  def hmset *fields
     redis.hmset(key,*fields)
   end
 
-  def vals
+  def hvals
     redis.hvals(key)
   end
-  alias values vals
+  alias values hvals
 
-  def keys
+  def hkeys
     redis.hkeys(key)
   end
 
-  def exists field
+  def hexists field
     redis.hexists(key,field)
   end
+  alias key? hexists
+  alias has_key? hexists
 
-  def get field
+  def hget field
     redis.hget(key,field)
   end
-  alias [] get
+  alias [] hget
 
-  def set field, val
+  def hset field, val
     redis.hset(key,field,val)
   end
-  alias []= set
+  alias []= hset
 
-  def getall
+  def hgetall
     redis.hgetall(key)
   end
-  alias to_h getall
+  alias to_h hgetall
+
+  def to_a
+    to_h.to_a
+  end
+
+  def each &blk
+    to_a.each(&blk)
+  end
 
-  def len
+  def hlen
     redis.hlen(key)
   end
-  alias size len
-  alias count len
-  alias length len
+  alias size hlen
+  alias count hlen
+  alias length hlen
+
+  def clear
+    redis.del(key) and self
+  end
+
+  def empty?
+    hlen == 0
+  end
+
+  def has_key? key
+    keys.include?(key)
+  end
+  alias include? has_key?
+  alias member? has_key?
+
+  def has_value? val
+    values.include?(val)
+  end
+
+  def merge! hsh
+    redis.hmset(key,hsh.to_a.flatten)
+    self
+  end
+
+  # Allow for non prefixed versions of the commands to be sent
+  # as well as making future proof for new versions of redis
+  def method_missing method, *arguments, &blk
+    if redis.respond_to?(method)
+      # If its a method available to redis just pass it along with the key
+      # as the first argument
+      redis.__send__(method,key,*arguments,&blk)
+    else
+      # If redis responds to the method prefixed with an h pass it along
+      if method.to_s[0] != 'h' && (new_method = "h#{method}") && redis.respond_to?(new_method)
+        self.send(new_method,*arguments,&blk)
+      else
+        super
+      end
+    end
+  end
 
-  def setnx field, val
-    redis.hsetnx(key,field,val)
+  def respond_to_missing?(method, include_private = false)
+    return true if redis.respond_to?(method)
+    method = method.to_s
+    method[0] != 'h' && redis.respond_to?("h#{method}") or super
   end
 end

data/lib/redis_obj/list.rb

@@ -1,58 +1,39 @@
 class RedisObj::List < RedisObj::Base
   include Enumerable
 
-  def blpop *args
-    redis.blpop(key,*args)
+  def first num=1
+    lrange(0,num-1)
   end
 
-  def brpop *args
-    redis.brpop(key,*args)
+  def take n
+    first(n)
   end
 
-  def brpoplpush(destination, options = {})
-    redis.brpoplpush(key,destination,options)
-  end
-
-  def lindex(index)
-    redis.lindex(key,index)
-  end
-  alias [] lindex
-
-  def linsert(where, pivot, value)
-    redis.linsert(key,where,pivot,value)
-  end
-
-  def lrange(start, stop)
-    redis.lrange(key, start, stop)
+  def last num=1
+    lrange(-1*num,-1)
   end
 
   def to_a
     lrange(0,-1)
   end
 
-  def each &blk
-    to_a.each(&blk)
-  end
-
-  def lrem(count, value)
-    redis.lrem(key, count, value)
+  def lindex(index)
+    redis.lindex(key,index)
   end
+  alias [] lindex
+  alias at lindex
 
   def lset(index, value)
     redis.lset(key, index, value)
   end
   alias []= lset
 
-  def ltrim(start, stop)
-    redis.ltrim(key, start, stop)
-  end
-
-  def len
+  def llen
     redis.llen(key)
   end
-  alias length len
-  alias size len
-  alias count len
+  alias length llen
+  alias size llen
+  alias count llen
 
   def lpop
     redis.lpop(key)
@@ -60,30 +41,65 @@ class RedisObj::List < RedisObj::Base
   alias shift lpop
 
   def lpush val
-    redis.lpush(val)
+    redis.lpush(key,val)
   end
   alias unshift lpush
 
-  def lpushx val
-    redis.lpushx(key,val)
-  end
-
   def rpop
     redis.rpop(key)
   end
   alias pop rpop
 
-  def rpoplpush destination
-    redis.rpoplpush(key, destination)
-  end
-
   def rpush val
     redis.rpush(key,val)
   end
   alias << rpush
   alias push rpush
 
-  def rpushx val
-    redis.rpushx(key,val)
+  def include?(val)
+    warn('Calling include on redis list, must pull down entire list to process')
+    !!find {|v| v == val}
+  end
+
+  def drop n
+    redis.ltrim(key,n,-1)
+    self
+  end
+
+  def sample n=1
+    cnt = llen
+    if n==1
+      lindex(rand(cnt))
+    else
+      arr = []
+      n.times do
+        arr << lindex(rand(cnt))
+      end
+      arr
+    end
+  end
+
+  # Make future proof for new versions of redis
+  def method_missing method, *arguments, &blk
+    if redis.respond_to?(method)
+      # If its a method available to redis just pass it along with the key
+      # as the first argument
+      redis.__send__(method,key,*arguments,&blk)
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(method, include_private = false)
+    redis.respond_to?(method) || super
+  end
+
+  def_delegators :_delegated_to_a, :pack, :join, :each, :uniq
+
+  private
+
+  def _delegated_to_a
+    warn('Calling include on redis list, must pull down entire list to process')
+    to_a
   end
 end

data/lib/redis_obj/set.rb

@@ -1,74 +1,48 @@
 class RedisObj::Set < RedisObj::Base
   include Enumerable
 
-  def members
+  def smembers
     redis.smembers(key)
   end
-  alias to_a members
+  alias to_a smembers
 
-  def ismember val
+  def each &blk
+    to_a.each(&blk)
+  end
+
+  def sismember val
     redis.sismember(key,val)
   end
-  alias include? ismember
+  alias include? sismember
 
-  def inter *keys
+  def sinter *keys
     redis.sinter(key,*get_keys(keys))
   end
-  alias & inter
-
-  def interstore destination, *keys
-    redis.sinterstore(destination,key,*get_keys(keys))
-    new_key = self.class.new(redis,destination)
-
-    if block_given?
-      begin
-        yield(new_key)
-      ensure
-        redis.del(destination)
-      end
-    end
+  alias & sinter
+  alias intersection sinter
 
-    new_key
+  def sinterstore destination, *keys, &blk
+    store_block_syntax(:sinterstore,destination,keys,&blk)
   end
 
-  def diff *keys
+  def sdiff *keys
     redis.sdiff(key,*get_keys(keys))
   end
-  alias - diff
-
-  def diffstore destination, *keys
-    redis.sdiffstore(destination,key,*get_keys(keys))
-    new_key = self.class.new(redis,destination)
+  alias - sdiff
+  alias difference sdiff
 
-    if block_given?
-      begin
-        yield(new_key)
-      ensure
-        redis.del(destination)
-      end
-    end
-
-    new_key
+  def sdiffstore destination, *keys, &blk
+    store_block_syntax(:sdiffstore,destination,keys,&blk)
   end
 
-  def union *keys
+  def sunion *keys
     redis.sunion(key,*get_keys(keys))
   end
-  alias | union
-
-  def unionstore destination, *keys
-    redis.sunionstore(destination,key,*get_keys(keys))
-    new_key = self.class.new(redis,destination)
-
-    if block_given?
-      begin
-        yield(new_key)
-      ensure
-        redis.del(destination)
-      end
-    end
+  alias | sunion
+  alias + sunion
 
-    new_key
+  def sunionstore destination, *keys, &blk
+    store_block_syntax(:sunionstore,destination,keys,&blk)
   end
 
   def pop
@@ -77,25 +51,91 @@ class RedisObj::Set < RedisObj::Base
 
   def add val
     redis.sadd(key,val)
+    self
   end
   alias << add
 
-  def rem val
-    redis.srem(key,val)
+  def add? val
+    redis.sadd(key,val) ? self : nil
+  end
+
+  def remove(val)
+    srem(val)
+    self
+  end
+
+  def remove?(val)
+    srem(val) ? self : nil
   end
 
   def srandmember num=1
     redis.srandmember(key,num)
   end
+  alias sample srandmember
 
-  def card
+  def scard
     redis.scard(key)
   end
-  alias length card
-  alias size card
-  alias count card
+  alias length scard
+  alias size scard
+  alias count scard
 
-  def each &blk
-    to_a.each(&blk)
+  def empty?
+    scard == 0
+  end
+
+  def delete_if(&blk)
+    vals_to_delete = select(&blk)
+    redis.srem(key,vals_to_delete)
+    vals_to_delete
+  end
+
+  # Allow for non prefixed versions of the commands to be sent
+  # as well as making future proof for new versions of redis
+  def method_missing method, *arguments, &blk
+    if redis.respond_to?(method)
+      # If its a method available to redis just pass it along with the key
+      # as the first argument
+      redis.__send__(method,key,*arguments,&blk)
+    else
+      # If redis responds to the method prefixed with an h pass it along
+      if method.to_s[0] != 's' && (new_method = "s#{method}") && redis.respond_to?(new_method)
+        self.send(new_method,*arguments,&blk)
+      else
+        super
+      end
+    end
+  end
+
+  def respond_to_missing?(method, include_private = false)
+    return true if redis.respond_to?(method)
+    method = method.to_s
+    method[0] != 's' && redis.respond_to?("s#{method}") or super
+  end
+
+  private
+
+  # If a block is passed yeild up the new key object and
+  # then delete the key afterwards
+  def store_block_syntax(command, destination, keys, &blk)
+    if block_given?
+      keys.unshift destination
+      destination = SecureRandom.uuid
+    end
+
+    keys.unshift(key)
+    redis.__send__(command,destination,*get_keys(keys))
+
+    new_key = self.class.new(redis,destination)
+
+    if block_given?
+      begin
+        yield(new_key)
+      ensure
+        redis.del(destination)
+      end
+    else
+      new_key
+    end
   end
 end

data/lib/redis_obj/sorted_set.rb

@@ -1,14 +1,11 @@
 class RedisObj::SortedSet < RedisObj::Base
-  def add score, member
-    redis.zadd(key,score,member)
-  end
-
-  def rem member
-    redis.zrem(key,mem)
-  end
-
-  def card min=0,max=0
+  def card min=nil,max=nil
     if min
+      if min.respond_to?(:max) && min.respond_to?(:min)
+        max = min.max
+        min = min.min
+      end
+
       redis.zcount(key,min,max)
     else
       redis.zcard(key)
@@ -16,74 +13,84 @@ class RedisObj::SortedSet < RedisObj::Base
   end
   alias length card
   alias size card
-  alias count card
+  alias zcount card
 
-  def incby amt, member
+  def zincrby amt, member
     redis.zincby(key,amt,member)
   end
+  alias incby zincrby
 
   def inc member
-    incby(1,member)
+    incrby(1,member)
   end
+  alias incr inc
 
   def dec member
-    incby(-1,member)
+    incrby(-1,member)
   end
+  alias decr dec
 
-  def range start, stop, opts={}
-    redis.zrange(key,start,stop,opts)
-  end
+  def zremrangebyrank start, stop=nil
+    if start.respond_to?(:max) && start.respond_to?(:min)
+      stop = start.max
+      start = start.min
+    end
 
-  def revrange start, stop, opts={}
-    redis.zrevrange(key,start,stop,opts)
+    redis.zremrangebyrank(key,start,stop)
   end
 
-  def rangebyscore start, stop, opts={}
-    redis.zrangebyscore(key,start,stop,opts)
-  end
+  def zremrangebyscore start, stop=nil
+    if start.respond_to?(:max) && start.respond_to?(:min)
+      stop = start.max
+      start = start.min
+    end
 
-  def revrangebyscore start, stop, opts={}
-    redis.zrevrangebyscore(key,start,stop,opts)
+    redis.zremrangebyscore(key,start,stop)
   end
 
-  def rank mem
-    redis.rank(key,mem)
+  def zinterstore(destination, keys, options = {}, &blk)
+    store_block_syntax(:zinterstore,destination,keys,options,&blk)
   end
 
-  def revrank mem
-    redis.revrank(key,mem)
+  def zunionstore(destination, keys, options = {}, &blk)
+    store_block_syntax(:zunionstore,destination,keys,options,&blk)
   end
 
-  def remrangebyrank start, stop
-    redis.zremrangebyrank(key,start,stop)
+  # Allow for non prefixed versions of the commands to be sent
+  # as well as making future proof for new versions of redis
+  def method_missing method, *arguments, &blk
+    if redis.respond_to?(method)
+      # If its a method available to redis just pass it along with the key
+      # as the first argument
+      redis.__send__(method,key,*arguments,&blk)
+    else
+      # If redis responds to the method prefixed with an h pass it along
+      if method.to_s[0] != 'z' && (new_method = "z#{method}") && redis.respond_to?(new_method)
+        self.send(new_method,*arguments,&blk)
+      else
+        super
+      end
+    end
   end
 
-  def remrangebyscore start, stop
-    redis.zremrangebyscore(key,start,stop)
+  def respond_to_missing?(method, include_private = false)
+    return true if redis.respond_to?(method)
+    method = method.to_s
+    method[0] != 'z' && redis.respond_to?("z#{method}") or super
   end
 
-  def interstore(destination, keys, options = {})
-    keys = [key]+keys
-
-    redis.zinterstore(destination,keys,options)
-
-    new_key = self.class.new(redis,destination)
+  private
 
+  # If a block is passed yeild up the new key object and
+  # then delete the key afterwards
+  def store_block_syntax(command, destination, keys, options,&blk)
     if block_given?
-      begin
-        yield(new_key)
-      ensure
-        redis.del(destination)
-      end
+      keys.unshift destination
+      destination = SecureRandom.uuid
     end
 
-    new_key
-  end
-
-  def unionstore(destination, keys, options = {})
-    keys = [key]+keys
-
-    redis.zunionstore(destination,keys,options)
+    keys.unshift(key)
+    redis.__send__(command,destination,get_keys(keys),options)
 
     new_key = self.class.new(redis,destination)
 
@@ -93,9 +100,8 @@ class RedisObj::SortedSet < RedisObj::Base
       ensure
         redis.del(destination)
       end
+    else
+      new_key
     end
-
-    new_key
   end
-
 end

data/lib/redis_obj/version.rb

@@ -1,3 +1,3 @@
 module RedisObj
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/redis_obj.gemspec

@@ -22,5 +22,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec", '~> 2.14.0.rc1'
 end

data/spec/object_types/hash_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe RedisObj::Hash do
+  let(:redis_method) {:"some_redis_method!"}
+  let(:redis) { double(Redis, redis_method => true) }
+  let(:key) { "key#{rand}" }
+  let(:val) { rand }
+  subject {RedisObj::Hash.new(redis,key)}
+
+  it_should_behave_like "a method missing object", 'h'
+
+  describe '#hget' do
+    let(:index) { rand(10000) }
+    before do
+      expect(redis).to receive(:hget).with(key,index).once
+    end
+
+    it { subject.hget(index) }
+    it { subject.get(index) }
+    it { subject[index] }
+  end
+
+  describe '#hset' do
+    let(:index) { rand(10000) }
+    let(:val) { rand }
+    before do
+      expect(redis).to receive(:hset).with(key,index,val).once
+    end
+
+    it { subject.hset(index,val) }
+    it { subject.set(index,val) }
+    it { subject[index] = val}
+  end
+end

data/spec/object_types/list_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe RedisObj::List do
+  let(:redis_method) {:"some_redis_method!"}
+  let(:redis) { double(Redis, redis_method => true) }
+  let(:key) { "key#{rand}" }
+  let(:val) { rand }
+  subject {RedisObj::List.new(redis,key)}
+
+  it_should_behave_like "a method missing object"
+
+  describe '#lindex' do
+    let(:val) { rand }
+    before do
+      expect(redis).to receive(:lindex).with(key,val).once
+    end
+
+    it { subject.lindex(val) }
+    it { subject[val] }
+    it { subject.at(val) }
+  end
+
+  describe '#first' do
+    it "should work with no args" do
+      expect(redis).to receive(:lrange).with(key,0,0).once
+      subject.first
+    end
+
+    it "should work with no args" do
+      expect(redis).to receive(:lrange).with(key,0,2).once
+      subject.first(3)
+    end
+
+    it "should work with no args" do
+      expect(redis).to receive(:lrange).with(key,0,2).once
+      subject.take(3)
+    end
+  end
+
+  describe '#last' do
+    it "should work with no args" do
+      expect(redis).to receive(:lrange).with(key,-1,-1).once
+      subject.last
+    end
+
+    it "should work with no args" do
+      expect(redis).to receive(:lrange).with(key,-3,-1).once
+      subject.last(3)
+    end
+  end
+
+  describe '#set' do
+    let(:index) { rand(100000) }
+    before do
+      expect(redis).to receive(:lset).with(key,index,val).once
+    end
+
+    it { subject.lset(index,val) }
+    it { subject[index] = val }
+  end
+
+  describe '#llen' do
+    before do
+      expect(redis).to receive(:llen).with(key).once
+    end
+
+    it { subject.length }
+    it { subject.size }
+    it { subject.count }
+    it { subject.llen }
+  end
+
+  describe '#lpop' do
+    before do
+      expect(redis).to receive(:lpop).with(key).once
+    end
+
+    it { subject.lpop }
+    it { subject.shift }
+  end
+
+  describe '#lpush' do
+    before do
+      expect(redis).to receive(:lpush).with(key,val).once
+    end
+
+    it { subject.lpush val }
+    it { subject.unshift val }
+  end
+
+  describe '#rpop' do
+    before do
+      expect(redis).to receive(:rpop).with(key).once
+    end
+
+    it { subject.rpop }
+    it { subject.pop }
+  end
+
+  describe '#rpush' do
+    before do
+      expect(redis).to receive(:rpush).with(key,val).once
+    end
+
+    it { subject.rpush val }
+    it { subject << val}
+    it { subject.push val}
+  end
+
+end

data/spec/object_types/set_spec.rb

@@ -0,0 +1,206 @@
+require 'spec_helper'
+
+describe RedisObj::Set do
+  let(:redis_method) {:"some_redis_method!"}
+  let(:redis) { double(Redis, redis_method => true) }
+  let(:key) { "key#{rand}" }
+  let(:val) { rand }
+  subject {RedisObj::Set.new(redis,key)}
+
+  describe '#smembers' do
+    before do
+      expect(redis).to receive(:smembers).with(key).once
+    end
+
+    it { subject.smembers }
+    it { subject.to_a }
+    it { subject.members }
+  end
+
+  describe '#sismember' do
+    before do
+      expect(redis).to receive(:sismember).with(key,val).once
+    end
+
+    it { subject.sismember val }
+    it { subject.include? val }
+    it { subject.ismember val }
+  end
+
+  describe 'other key interaction' do
+    let(:keys) { %w{key1 key2 key3} }
+    let(:objs) { %w{key1 key2 key3}.collect {|k| RedisObj::Set.new(redis,k)} }
+    let(:destination) { 'destination' }
+
+    let(:test_key) {keys.first}
+    let(:test_objs) {objs.first}
+
+    describe '#sinter' do
+      before do
+        expect(redis).to receive(:sinter).with(key,*keys).once
+      end
+
+      it { subject.sinter *keys }
+      it { subject.sinter keys }
+      it { subject.inter keys }
+      it { subject & keys }
+      it { subject.intersection keys }
+
+      it { subject.sinter *objs }
+      it { subject.sinter objs }
+      it { subject.inter objs }
+      it { subject & objs }
+      it { subject.intersection objs }
+    end
+
+    describe '#sdiff' do
+      before do
+        expect(redis).to receive(:sdiff).with(key,*keys).once
+      end
+
+      it { subject.sdiff *keys }
+      it { subject.sdiff keys }
+      it { subject.diff keys }
+      it { subject - keys }
+      it { subject.difference keys }
+
+      it { subject.sdiff *objs }
+      it { subject.sdiff objs }
+      it { subject.diff objs }
+      it { subject - objs }
+      it { subject.difference objs }
+    end
+
+    describe '#sunion' do
+      before do
+        expect(redis).to receive(:sunion).with(key,*keys).once
+      end
+
+      it { subject.sunion *keys }
+      it { subject.sunion keys }
+      it { subject.union keys }
+      it { subject | keys }
+      it { subject + keys }
+
+      it { subject.sunion *objs }
+      it { subject.sunion objs }
+      it { subject.union objs }
+      it { subject | objs }
+      it { subject + objs }
+    end
+
+    describe '#sinterstore' do
+      before do
+        expect(redis).to receive(:sinterstore).with(destination,key,*keys).once
+      end
+
+      it { subject.sinterstore destination, *keys }
+      it { subject.interstore destination, keys }
+
+      it 'should delete key after when returning block' do
+        expect(redis).to receive(:del).with(destination).once
+        expect(redis).to receive(redis_method).with(destination).once
+        expect(SecureRandom).to receive(:uuid).once.and_return(destination)
+
+        subject.sinterstore *keys do |new_key|
+          new_key.send redis_method
+        end
+      end
+
+    end
+
+    describe '#sdiffstore' do
+      before do
+        expect(redis).to receive(:sdiffstore).with(destination,key,*keys).once
+      end
+
+      it { subject.sdiffstore destination, *keys }
+      it { subject.diffstore destination, keys }
+
+      it 'should delete key after when returning block' do
+        expect(redis).to receive(:del).with(destination).once
+        expect(redis).to receive(redis_method).with(destination).once
+        expect(SecureRandom).to receive(:uuid).once.and_return(destination)
+
+        subject.sdiffstore *keys do |new_key|
+          new_key.send redis_method
+        end
+      end
+
+    end
+
+    describe '#sunionstore' do
+      before do
+        expect(redis).to receive(:sunionstore).with(destination,key,*keys).once
+      end
+
+      it { subject.sunionstore destination, *keys }
+      it { subject.unionstore destination, keys }
+
+      it 'should delete key after when returning block' do
+        expect(redis).to receive(:del).with(destination).once
+        expect(redis).to receive(redis_method).with(destination).once
+        expect(SecureRandom).to receive(:uuid).once.and_return(destination)
+
+        subject.sunionstore *keys do |new_key|
+          new_key.send redis_method
+        end
+      end
+
+    end
+
+  end
+
+  describe '#pop' do
+    before do
+      expect(redis).to receive(:pop).with(key).once
+    end
+
+    it { subject.pop }
+  end
+
+  describe '#srandmember' do
+    before do
+      expect(redis).to receive(:srandmember).with(key,1).once
+    end
+
+    it { subject.srandmember }
+    it { subject.randmember }
+    it { subject.sample }
+  end
+
+  describe '#scard' do
+    before do
+      expect(redis).to receive(:scard).with(key).once
+    end
+
+    it { subject.scard }
+    it { subject.card }
+    it { subject.length }
+    it { subject.size }
+    it { subject.count }
+  end
+
+  describe '#add' do
+    let(:ret) {double('return')}
+    before do
+      expect(redis).to receive(:sadd).with(key,val).once.and_return(ret)
+    end
+
+    it { subject.add(val).should be subject }
+    it { subject.sadd(val).should be ret }
+    it { (subject << val).should be subject }
+  end
+
+  describe '#remove' do
+    let(:ret) {double('return')}
+    before do
+      expect(redis).to receive(:srem).with(key,val).once.and_return(ret)
+    end
+
+    it { subject.srem(val).should be ret }
+    it { subject.remove(val).should be subject }
+  end
+
+  it_should_behave_like "a method missing object", 's'
+end

data/spec/object_types/sorted_set_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe RedisObj::SortedSet do
+  let(:redis_method) {:"some_redis_method!"}
+  let(:redis) { double(Redis, redis_method => true) }
+  let(:key) { "key#{rand}" }
+  let(:val) { rand }
+  subject {RedisObj::SortedSet.new(redis,key)}
+
+  it_should_behave_like "a method missing object", 'z'
+end

data/spec/redis_obj_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe RedisObj do
-  let(:base_redis) { mock("BaseRedis") }
+  let(:base_redis) { double("BaseRedis") }
   before { RedisObj.redis = base_redis }
 
   let(:test_klass) do
@@ -37,7 +37,7 @@ describe RedisObj do
 
     describe "global redis instance" do
       subject{obj.friends}
-      let(:redis) {mock('Redis')}
+      let(:redis) {double('Redis')}
 
       before { RedisObj.redis = redis; test_klass.redis_set :friends }
       after { RedisObj.redis = base_redis }
@@ -63,7 +63,7 @@ describe RedisObj do
     end
 
     describe 'redis_set defined default key' do
-      let(:redis) {mock('Redis')}
+      let(:redis) {double('Redis')}
       before do
         test_klass.redis_set :friends
         test_klass.redis_set :friends2, key: 'f', redis: redis

data/spec/spec_helper.rb

@@ -16,7 +16,50 @@ RSpec.configure do |config|
   config.order = 'random'
 end
 
-$:.unshift(File.expand_path(File.join(File.dirname(__FILE__),'..','lib')))
+# $:.unshift(File.expand_path(File.join(File.dirname(__FILE__),'..','lib')))
 
 require 'redis'
 require 'redis_obj'
+
+
+shared_examples "a method missing object" do |has_pefix=false|
+  describe 'method missing' do
+    let(:non_redis_method) { :"rand_method_#{rand}" }
+
+    it 'should respond to redis methods' do
+      subject.respond_to?(redis_method).should be true
+    end
+
+    it 'should pass method along' do
+      expect(redis).to receive(redis_method).with(key)
+      subject.__send__(redis_method)
+    end
+
+    it 'should not respond to non redis methods' do
+      subject.respond_to?(non_redis_method).should be false
+    end
+
+    it 'should error if you call non redis method' do
+      redis.should_not_receive(:non_redis_method)
+      expect { subject.send(non_redis_method) }.to raise_error(NoMethodError)
+    end
+
+    if has_pefix
+      let(:prefixed_redis_method) { :"#{has_pefix}prefixed_redis_method" }
+      before do
+        allow(redis).to receive(prefixed_redis_method)
+      end
+
+      it { subject.respond_to?(prefixed_redis_method).should be true }
+      it 'should pass method along' do
+        expect(redis).to receive(prefixed_redis_method).with(key)
+        subject.__send__(prefixed_redis_method)
+      end
+      it { subject.respond_to?(:prefixed_redis_method).should be true }
+      it 'should pass method along' do
+        expect(redis).to receive(:prefixed_redis_method).with(key)
+        subject.__send__(:prefixed_redis_method)
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis_obj
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Tal Atlas
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-06 00:00:00.000000000 Z
+date: 2013-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -56,16 +56,16 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.14.0.rc1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.14.0.rc1
 description: methods for managing redis keys in an object oriented manner
 email:
 - me@tal.by
@@ -75,10 +75,12 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rspec
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- TODO.md
 - lib/redis_obj.rb
 - lib/redis_obj/base.rb
 - lib/redis_obj/hash.rb
@@ -88,6 +90,10 @@ files:
 - lib/redis_obj/sorted_set.rb
 - lib/redis_obj/version.rb
 - redis_obj.gemspec
+- spec/object_types/hash_spec.rb
+- spec/object_types/list_spec.rb
+- spec/object_types/set_spec.rb
+- spec/object_types/sorted_set_spec.rb
 - spec/redis_obj_class_methods_spec.rb
 - spec/redis_obj_spec.rb
 - spec/spec_helper.rb
@@ -116,6 +122,10 @@ signing_key:
 specification_version: 4
 summary: kinda like a redis ORM
 test_files:
+- spec/object_types/hash_spec.rb
+- spec/object_types/list_spec.rb
+- spec/object_types/set_spec.rb
+- spec/object_types/sorted_set_spec.rb
 - spec/redis_obj_class_methods_spec.rb
 - spec/redis_obj_spec.rb
 - spec/spec_helper.rb