redness 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 HowAboutWe
+
+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/RAKEFILE

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'rake'
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec

data/README.rdoc

@@ -0,0 +1 @@
+WIP

data/lib/redness/red.rb

@@ -0,0 +1,35 @@
+class Red
+  class RedisUnavailable < StandardError; end
+
+  def self.redis
+    $redis
+  end
+
+  def self.delete(key)
+    redis.del(key)
+  end
+
+  def redis
+    Red.redis
+  end
+
+  def execute_with_uncertainty(fail_return = [])
+    yield
+  rescue RedisUnavailable, Errno::ECONNREFUSED, Timeout, Timeout::Error, Errno::EAGAIN
+    fail_return
+  end
+
+  def multi_with_caution(fail_return = [])
+    redis.multi
+    yield
+    redis.exec
+  rescue
+    redis.discard
+    fail_return
+  end
+
+  def method_missing(method, *args)
+    raise RedisUnavailable unless redis
+    redis.send(method, *args)
+  end
+end

data/lib/redness/red_capped_list.rb

@@ -0,0 +1,17 @@
+class RedCappedList
+  attr_accessor :key, :cap
+
+  def initialize(key, cap)
+    self.key = key
+    self.cap = cap
+  end
+
+  def get
+    RedList.get(key)
+  end
+
+  def add(value)
+    RedList.add(key, value)
+    RedList.trim_to(key, cap)
+  end
+end

data/lib/redness/red_expire.rb

@@ -0,0 +1,11 @@
+class RedExpire < Red
+  def self.redis
+    @redis ||= Red.new
+  end
+
+  def self.set(key, expires_in)
+    redis.execute_with_uncertainty(nil) do
+      redis.expire(key, expires_in.seconds.to_i)
+    end
+  end
+end

data/lib/redness/red_hash.rb

@@ -0,0 +1,51 @@
+class RedHash
+  attr_accessor :hash_key, :redis
+
+  def initialize(hash_key = self.class.name, redis = Red.new)
+    self.hash_key = hash_key
+    self.redis = redis
+  end
+
+  def []=(key, value)
+    redis.execute_with_uncertainty(nil) do
+      redis.hset(hash_key, key, value)
+      value
+    end
+  end
+
+  def [](key)
+    redis.execute_with_uncertainty(nil) do
+      redis.hget(hash_key, key)
+    end
+  end
+
+  def remove(key)
+    redis.execute_with_uncertainty(false) do
+      redis.hdel(hash_key, key)
+    end
+  end
+
+  def all
+    redis.execute_with_uncertainty({}) do
+      hash = redis.hgetall(hash_key)
+
+      HashWithIndifferentAccess.new(hash)
+    end
+  end
+
+  def clear
+    redis.execute_with_uncertainty(false) do
+      redis.hkeys(hash_key).each do |key|
+        redis.hdel(hash_key, key)
+      end
+    end
+  end
+
+  def set(options)
+    redis.execute_with_uncertainty(false) do
+      options.keys.each do |option|
+        self[option] = options[option]
+      end
+    end
+  end
+end

data/lib/redness/red_json.rb

@@ -0,0 +1,21 @@
+class RedJSON < Red
+  def self.redis
+    @redis ||= Red.new
+  end
+
+  def self.get(key)
+    redis.execute_with_uncertainty(nil) do
+      value = redis.get(key)
+
+      if value
+        JSON.parse(value)
+      end
+    end
+  end
+
+  def self.set(key, value)
+    redis.execute_with_uncertainty(nil) do
+      redis.set(key, value.to_json)
+    end
+  end
+end

data/lib/redness/red_list.rb

@@ -0,0 +1,50 @@
+class RedList
+  def self.redis
+    @redis ||= Red.new
+  end
+
+  def self.get(key)
+    redis.execute_with_uncertainty([]) do
+      redis.lrange(key, 0, -1).map(&:to_i)
+    end
+  end
+
+  def self.get_strings(key)
+    redis.execute_with_uncertainty([]) do
+      redis.lrange(key, 0, -1)
+    end
+  end
+
+  def self.add(key, value)
+    redis.execute_with_uncertainty(false) do
+      redis.lpush(key, value)
+    end
+  end
+
+  def self.remove(key, value, occurrences = 0)
+    redis.execute_with_uncertainty(false) do
+      redis.lrem(key, occurrences, value)
+    end
+  end
+
+  def self.count(key, value)
+    get(key).count(value)
+  end
+
+  def self.total_size(key)
+    get(key).count
+  end
+
+  def self.trim_to(key, amount)
+    redis.execute_with_uncertainty(false) do
+      redis.ltrim(key, 0, (amount - 1))
+    end
+  end
+
+  def self.pop(key)
+    redis.execute_with_uncertainty(false) do
+      redis.rpop(key)
+    end
+  end
+
+end

data/lib/redness/red_set.rb

@@ -0,0 +1,76 @@
+class RedSet
+  def self.redis
+    @redis ||= Red.new
+  end
+
+  def self.add(key, member, options = {})
+    redis.execute_with_uncertainty do
+      redis.watch(key)
+
+      if redis.zrank(key, member).nil?
+        if options[:score] and options[:score].respond_to?(:call)
+          score = options[:score].call.to_i
+        else
+          score = redis.zcard(key).to_i
+        end
+
+        redis.multi_with_caution(false) do
+          redis.zadd(key, score.to_s, member)
+        end
+      end
+    end
+
+  ensure
+    redis.execute_with_uncertainty(0) do
+      redis.unwatch
+    end
+  end
+
+
+  def self.remove(key, member)
+    redis.execute_with_uncertainty do
+      redis.zrem(key, member)
+    end
+  end
+
+  def self.get(key, options = {})
+    lower_bound = options[:lower] || 0
+    upper_bound = options[:upper] || -1
+    with_scores = options[:with_scores] || false
+    scoring     = options[:scoring] || lambda {|x| x}
+
+    redis.execute_with_uncertainty([]) do
+      results = redis.zrevrange(key, lower_bound, upper_bound, :with_scores => with_scores)
+      if with_scores
+        [].tap do |memo|
+          results.each_slice(2) do |slice|
+            memo << [slice[0].to_i, scoring.call(slice[1].to_i)]
+          end
+        end
+      else
+        results.map(&:to_i)
+      end
+    end
+  end
+
+  def self.get_strings(key, options = {})
+    lower_bound = options[:lower] || 0
+    upper_bound = options[:upper] || -1
+
+    redis.execute_with_uncertainty do
+      redis.zrevrange(key, lower_bound, upper_bound)
+    end
+  end
+
+  def self.count(key)
+    redis.execute_with_uncertainty(0) do
+      redis.zcard(key)
+    end
+  end
+
+  def self.score(key, member)
+    redis.execute_with_uncertainty(nil) do
+      redis.zscore(key, member)
+    end
+  end
+end

data/lib/redness/red_set_multi.rb

@@ -0,0 +1,23 @@
+class RedSetMulti
+  attr_accessor :keys, :redis
+
+  def initialize(*keys)
+    self.keys = keys
+    self.redis = Red.new
+  end
+
+  def get(options = {})
+    lower_bound = options[:lower] || 0
+    upper_bound = options[:upper] || -1
+
+    redis.execute_with_uncertainty([]) do
+      results = keys.map { |key| redis.zrevrange(key, lower_bound, upper_bound) }
+
+      if results.present?
+        results.map {|r| r.map(&:to_i)}
+      else
+        []
+      end
+    end
+  end
+end

data/lib/redness/red_set_union.rb

@@ -0,0 +1,29 @@
+class RedSetUnion
+  attr_accessor :keys, :redis
+
+  def initialize(*keys)
+    self.keys = keys
+    self.redis = Red.new
+
+    @temporary_key = "tmp:red_set_union"
+  end
+
+  def get(options = {})
+    lower_bound = options[:lower] || 0
+    upper_bound = options[:upper] || -1
+
+    redis.execute_with_uncertainty([]) do
+      results = redis.multi_with_caution do
+        redis.zunionstore(@temporary_key, keys)
+        redis.zrevrange(@temporary_key, lower_bound, upper_bound)
+        redis.del(@temporary_key)
+      end
+
+      if results.present?
+        results[1].flatten.compact.uniq.map(&:to_i)
+      else
+        []
+      end
+    end
+  end
+end

data/lib/redness/timed_red_set.rb

@@ -0,0 +1,33 @@
+class TimedRedSet < RedSet
+  def self.add(key, member)
+    super(key, member, :score => lambda { Precisionable.int_from_float(Time.now) })
+  end
+
+  def self.since(key, start, options={})
+    precise_start = Precisionable.int_from_float(start)
+
+    redis.execute_with_uncertainty([]) do
+      if options[:upper] and options[:lower]
+        lower = options[:lower].to_i
+        upper = options[:upper].to_i
+
+        redis.zrevrangebyscore(key, "+inf", precise_start)[lower..upper].map(&:to_i)
+      else
+        redis.zrevrangebyscore(key, "+inf", precise_start).map(&:to_i)
+      end
+    end
+  end
+
+  def self.score(key, member)
+    precise_time = super
+    Time.at(Precisionable.float_from_int(precise_time)) if precise_time
+  end
+
+  def self.get_with_timestamps(key, options = {})
+    get(key, options.merge({
+        :with_scores => true,
+        :scoring => lambda {|x| Time.at(Precisionable.float_from_int(x))}
+      })
+    )
+  end
+end

data/lib/redness.rb

@@ -0,0 +1,10 @@
+require "redness/red"
+require "redness/red_capped_list"
+require "redness/red_expire"
+require "redness/red_hash"
+require "redness/red_json"
+require "redness/red_list"
+require "redness/red_set"
+require "redness/red_set_multi"
+require "redness/red_set_union"
+require "redness/timed_red_set"

data/lib/version.rb

@@ -0,0 +1,4 @@
+module Redness
+  VERSION="0.0.1"
+  MAJOR, MINOR, TINY = VERSION.split(".")
+end

data/redness.gemspec

@@ -0,0 +1,26 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "version"
+
+Gem::Specification.new do |s|
+  s.name = "redness"
+  s.version = Redness::VERSION
+  s.authors = %w(
+    Baldur Gudbjornsson
+    Matt Vermaak
+    Bryan Woods
+    Kenneth Lay
+    Marco Carag
+    Conner Peirce
+  )
+  s.email = "dev@howaboutwe.com"
+  s.summary = "Helpful Ruby classes for improved Redis data structures"
+  s.description = "Helpful Ruby classes for improved Redis data structures"
+  s.homepage = "http://github.com/howaboutwe/redness"
+  s.licenses = ["MIT"]
+  s.files = `git ls-files`.split("\n")
+  s.add_dependency "rspec"
+  s.add_dependency "redis", "~> 2.2.2"
+  s.add_dependency "active_support"
+  s.add_dependency "timecop"
+  s.require_paths = ["lib"]
+end

data/spec/precisionable.rb

@@ -0,0 +1,11 @@
+module Precisionable
+  PRECISION = 100000.0
+
+  def self.int_from_float(float)
+    (float.to_f * PRECISION).round
+  end
+
+  def self.float_from_int(int)
+    (int.to_f / PRECISION)
+  end
+end

data/spec/redis_runner.rb

@@ -0,0 +1,29 @@
+class RedisRunner
+  def self.start
+    fork do
+      `cd tmp && echo port #{port} | redis-server -`
+       at_exit { exit! }
+    end
+  end
+
+  def self.stop
+    `redis-cli -h #{host} -p #{port} 'SHUTDOWN'`
+
+    "#{host}:#{port}"
+  end
+
+  def self.up?
+    system("redis-cli -h #{host} -p #{port} 'INFO' 2&>1 > /dev/null")
+    $? == 0
+  end
+
+  private
+
+  def self.host
+    "localhost"
+  end
+
+  def self.port
+    "6379"
+  end
+end

data/spec/redness/red_capped_list_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_integration_helper'
+
+describe RedCappedList do
+  describe ".new" do
+    it "returns an instance of RedCappedList with cap and key set" do
+      r = RedCappedList.new("somekey", 1000)
+      r.key.should == "somekey"
+      r.cap.should == 1000
+    end
+  end
+
+  describe "#get" do
+    it "returns the list at the key" do
+      r = RedCappedList.new("somekey", 1000)
+      r.get.should == []
+    end
+  end
+
+  describe "#add" do
+    it "adds to the list at the key" do
+      r = RedCappedList.new("somekey", 1000)
+      r.add(1)
+      r.get.should == [1]
+    end
+
+    it "keeps the collection capped at the cap" do
+      r = RedCappedList.new("somekey", 1)
+      r.add(1)
+      r.get.should == [1]
+      r.add(2)
+      r.get.should == [2]
+    end
+  end
+end

data/spec/redness/red_expire_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_integration_helper'
+
+describe RedExpire do
+  describe ".set" do
+    it "expires the key in the given seconds" do
+      RedJSON.set('test', 1)
+      RedExpire.set('test', 0.seconds)
+      RedJSON.get('test').should be_nil
+    end
+  end
+end

data/spec/redness/red_hash_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_integration_helper'
+
+describe RedHash do
+  let(:red_hash) { RedHash.new("configuration") }
+
+  describe ".new" do
+    it "returns a red hash whose hash key is set to the first parameter" do
+      r = RedHash.new("test")
+      r.hash_key.should == "test"
+    end
+
+    it "uses the class name as the default hash key if no parameter is passed" do
+      r = RedHash.new
+      r.hash_key.should == "RedHash"
+    end
+  end
+
+  describe "#[]=" do
+    it "sets a key" do
+      red_hash[:key] = "value"
+      red_hash[:key].should == "value"
+    end
+  end
+
+  describe "#[]" do
+    it "gets a key" do
+      red_hash[:key] = "value"
+      red_hash[:key].should == "value"
+    end
+
+    it "returns nil if the key does not exist" do
+      red_hash[:non_key].should be_nil
+    end
+
+    it "should get different values depending on hash_key" do
+      red_hash[:key] = "value"
+
+      another_hash = RedHash.new("another_hash")
+      another_hash[:key] = "value2"
+
+      red_hash[:key].should == "value"
+      another_hash[:key].should == "value2"
+    end
+  end
+
+  describe "#all" do
+    it "gets the entire hash" do
+      red_hash[:key] = "value"
+      red_hash[:another_key] = "another_value"
+
+      red_hash.all.should == {
+        "key"         => "value",
+        "another_key" => "another_value"
+      }
+    end
+  end
+
+  describe "#remove" do
+    it "removes a key" do
+      red_hash[:key] = "value"
+      red_hash[:key].should == "value"
+
+      red_hash.remove(:key)
+      red_hash[:key].should be_nil
+    end
+  end
+
+  describe "#clear" do
+    it "removes all keys" do
+      red_hash[:key] = "value"
+      red_hash[:another_key] = "another_value"
+
+      red_hash.clear
+      red_hash.all.should == {}
+    end
+  end
+
+  describe "#set" do
+    it "accepts a hash, and sets all keys" do
+      red_hash.set(
+        :key => "something",
+        :another_key => "something_else"
+      )
+
+      red_hash["another_key"].should == "something_else"
+      red_hash["key"].should == "something"
+    end
+  end
+end

data/spec/redness/red_json_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_integration_helper'
+
+describe RedJSON do
+  describe ".set and .get" do
+    it "stores json at the provided key" do
+      RedJSON.set("test", [1,2,3])
+      RedJSON.get("test").should == [1,2,3]
+    end
+  end
+end

data/spec/redness/red_list_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_integration_helper'
+
+describe RedList do
+  describe ".add" do
+    it "adds a member to the list" do
+      RedList.add("somekey", 2)
+      list = RedList.get("somekey")
+
+      list.should == [2]
+    end
+
+    it "allows duplicates in the list" do
+      RedList.add("somekey", 2)
+      RedList.add("somekey", 2)
+
+      list = RedList.get("somekey")
+      list.should == [2,2]
+    end
+  end
+
+  describe ".remove" do
+    it "removes all matching values in list" do
+      RedList.add("somekey", 2)
+      RedList.add("somekey", 3)
+      RedList.add("somekey", 2)
+
+      RedList.remove("somekey", 2)
+      list = RedList.get("somekey")
+      list.should == [3]
+    end
+
+    context "supplied count" do
+      it "removes first {count} occurrences of value in list" do
+        RedList.add("somekey", 2)
+        RedList.add("somekey", 3)
+        RedList.add("somekey", 2)
+
+        RedList.remove("somekey", 2, 1)
+        list = RedList.get("somekey")
+        list.should == [3, 2]
+      end
+    end
+  end
+
+  describe ".get" do
+    it "returns the list in that key" do
+      RedList.add("somekey", 1)
+      RedList.add("somekey", 2)
+
+      RedList.get("somekey").should == [2,1]
+    end
+  end
+
+  describe ".count" do
+    it "returns the number of occurrences of the value within the list" do
+      RedList.add("somekey", 1)
+      RedList.add("somekey", 1)
+      RedList.add("somekey", 2)
+
+      RedList.count("somekey", 1).should == 2
+    end
+  end
+
+  describe ".total_size" do
+    it "retuns the total size of the array (list)" do
+      RedList.total_size("foobar").should == 0
+      RedList.add("foobar","a")
+      RedList.total_size("foobar").should == 1
+      RedList.add("foobar","b")
+      RedList.total_size("foobar").should == 2
+    end
+  end
+
+  describe ".pop" do
+    it "removes the last element in the list" do
+      RedList.add("foobar2", "a")
+      RedList.add("foobar2", "b")
+      RedList.add("foobar2", "c")
+
+      RedList.redis.lrange("foobar2", 0, -1).should == ["c", "b", "a"]
+      RedList.pop("foobar2").should == "a"
+      RedList.redis.lrange("foobar2", 0, -1).should == ["c", "b"]
+    end
+  end
+
+  describe ".trim_to" do
+    it "removes elements from the list until {amount} remain" do
+      RedList.add("somekey", 1)
+      RedList.add("somekey", 2)
+      RedList.add("somekey", 3)
+
+      RedList.trim_to("somekey", 1)
+      RedList.get("somekey").should == [3]
+    end
+  end
+end

data/spec/redness/red_set_multi_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_integration_helper'
+
+describe RedSetMulti do
+  describe "#new" do
+    it "returns an instance of RedSetMulti with keys set" do
+      r = RedSetMulti.new("key1", "key2")
+      r.keys.should == ["key1", "key2"]
+    end
+  end
+
+  describe "#get" do
+    context "RedSet" do
+      before do
+        RedSet.add("key1", 1)
+        RedSet.add("key1", 2)
+        RedSet.add("key1", 3)
+
+        RedSet.add("key2", 1)
+        RedSet.add("key2", 6)
+        RedSet.add("key2", 7)
+
+        RedSet.add("key3", 9)
+      end
+
+      it "returns an array with all of the unique values ordered by score" do
+        r = RedSetMulti.new("key1", "key2", "key3")
+        r.get.should == [[3,2,1],[7,6,1],[9]]
+      end
+
+      context "with non existent key" do
+        it "does not return nils" do
+          r = RedSetMulti.new("key1", "key2", "key3", "nonexistent")
+          r.get.should == [[3,2,1],[7,6,1],[9],[]]
+        end
+      end
+    end
+
+    context "TimedRedSet" do
+      before do
+        TimedRedSet.add("key1", 1)
+        TimedRedSet.add("key1", 2)
+        TimedRedSet.add("key1", 3)
+
+        TimedRedSet.add("key2", 1)
+        TimedRedSet.add("key2", 6)
+        TimedRedSet.add("key2", 7)
+
+        TimedRedSet.add("key3", 9)
+      end
+
+      it "returns an array with all of the unique values ordered by score" do
+        r = RedSetMulti.new("key1", "key2", "key3")
+        r.get.should == [[3,2,1],[7,6,1],[9]]
+      end
+
+      context "with non existent key" do
+        it "does not return nils" do
+          r = RedSetMulti.new("key1", "nonexistent", "key2", "key3")
+          r.get.should == [[3,2,1],[],[7,6,1],[9]]
+        end
+      end
+    end
+  end
+
+end

data/spec/redness/red_set_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_integration_helper'
+
+describe RedSet do
+  describe ".add" do
+    it "should add a member to the set" do
+      RedSet.add("somekey", 2)
+      set = RedSet.get("somekey")
+
+      set.should == [2]
+    end
+
+    it "should not add duplicates to the set" do
+      RedSet.add("somekey", 2)
+      RedSet.add("somekey", 2)
+
+      set = RedSet.get("somekey")
+
+      set.should == [2]
+    end
+
+    it "should not change the order of the set on attempted duplicate" do
+      RedSet.add("somekey", 2)
+      RedSet.add("somekey", 3)
+      RedSet.add("somekey", 2)
+
+      set = RedSet.get("somekey")
+
+      set.should == [3,2]
+    end
+
+    it "sets the score when one is provided" do
+      RedSet.add("somekey", 1, :score => lambda { 1000 })
+
+      RedSet.score("somekey", 1).should == "1000"
+    end
+  end
+
+  describe ".remove" do
+    it "should remove a member from the set" do
+      RedSet.add("somekey", 1)
+      RedSet.add("somekey", 2)
+
+      RedSet.remove("somekey", 2)
+
+      RedSet.get("somekey").should == [1]
+    end
+  end
+
+  describe ".score" do
+    it "returns the score of member within key" do
+      RedSet.add("somekey", 1)
+
+      RedSet.score("somekey", 1).should == "0"
+    end
+  end
+
+  describe ".get" do
+    describe "pagination" do
+      it "should return results bounded by provided options" do
+        RedSet.add("somekey", 1)
+        RedSet.add("somekey", 2)
+
+        RedSet.get("somekey", :lower => 0, :upper => 0).should == [2]
+        RedSet.get("somekey", :lower => 1, :upper => 1).should == [1]
+      end
+    end
+  end
+
+  describe ".count" do
+    it "should return the total count" do
+      7.times {|i| RedSet.add("somekey",i)}
+
+      RedSet.count("somekey").should == 7
+    end
+  end
+end

data/spec/redness/red_set_union_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_integration_helper'
+
+describe RedSetUnion do
+  describe ".new" do
+    it "returns an instance of RedMultiSet with keys set" do
+      r = RedSetUnion.new("key1", "key2", "key3")
+      r.keys.should == ["key1", "key2", "key3"]
+    end
+  end
+
+  describe "#get" do
+    context "RedSet" do
+      before do
+        RedSet.add("key1", 1)
+        RedSet.add("key1", 2)
+        RedSet.add("key1", 3)
+
+        RedSet.add("key2", 1)
+        RedSet.add("key2", 6)
+        RedSet.add("key2", 7)
+
+        RedSet.add("key3", 9)
+      end
+
+      it "returns an array with all of the unique values ordered by score" do
+        r = RedSetUnion.new("key1", "key2", "key3")
+        r.get.should == [7,3,6,2,9,1]
+      end
+
+      context "with non existent key" do
+        it "does not return nils" do
+          r = RedSetUnion.new("key1", "key2", "key3", "nonexistent")
+          r.get.should == [7,3,6,2,9,1]
+        end
+      end
+    end
+
+    context "TimedRedSet" do
+      before do
+        TimedRedSet.add("key1", 1)
+        TimedRedSet.add("key1", 2)
+        TimedRedSet.add("key1", 3)
+
+        TimedRedSet.add("key2", 1)
+        TimedRedSet.add("key2", 6)
+        TimedRedSet.add("key2", 7)
+
+        TimedRedSet.add("key3", 9)
+      end
+
+      it "returns an array with all of the unique values ordered by score" do
+        r = RedSetUnion.new("key1", "key2", "key3")
+        r.get.should == [1,9,7,6,3,2]
+      end
+
+      context "with non existent key" do
+        it "does not return nils" do
+          r = RedSetUnion.new("key1", "nonexistent", "key2", "key3")
+          r.get.should == [1,9,7,6,3,2]
+        end
+      end
+    end
+  end
+end

data/spec/redness/timed_red_set_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_integration_helper'
+
+describe TimedRedSet do
+  describe ".add" do
+    it "adds a member to the set" do
+      TimedRedSet.add("somekey", 1)
+
+      set = TimedRedSet.get("somekey")
+
+      set.should == [1]
+    end
+
+    it "adds a member to the set with a timestamp for score" do
+      the_time = Time.now
+      Timecop.freeze(the_time) do
+        TimedRedSet.add("somekey", 1)
+
+        TimedRedSet.score("somekey", 1).to_s.should == the_time.to_s
+      end
+    end
+  end
+
+  describe ".since" do
+    it "returns the additions since a start time" do
+      the_past = 2.days.ago
+
+      Timecop.freeze(the_past) do
+        TimedRedSet.add("somekey", 1)
+      end
+
+      TimedRedSet.add("somekey", 2)
+
+      TimedRedSet.since("somekey", 1.day.ago).should == [2]
+    end
+
+    it "returns results sorted in reverse chronological order" do
+      the_past = 2.days.ago
+
+      Timecop.freeze(the_past) do
+        TimedRedSet.add("somekey", 1)
+      end
+
+      TimedRedSet.add("somekey", 2)
+
+      TimedRedSet.since("somekey", 3.days.ago).should == [2, 1]
+    end
+
+    it "accepts an upper and lower bound" do
+      TimedRedSet.add("somekey", 1)
+      TimedRedSet.add("somekey", 2)
+      TimedRedSet.add("somekey", 3)
+
+      TimedRedSet.since("somekey", 1.day.ago, :lower => 0, :upper => 0).should == [3]
+      TimedRedSet.since("somekey", 1.day.ago, :lower => 0, :upper => 1).should == [3,2]
+      TimedRedSet.since("somekey", 1.day.ago, :lower => 1, :upper => 2).should == [2,1]
+    end
+  end
+
+  describe ".get_with_timestamps" do
+    it "returns members of the set with times" do
+      TimedRedSet.add("somekey", 1)
+      TimedRedSet.add("somekey", 2)
+      TimedRedSet.add("somekey", 3)
+
+      TimedRedSet.get_with_timestamps("somekey").should == [
+        [3, TimedRedSet.score("somekey", 3)],
+        [2, TimedRedSet.score("somekey", 2)],
+        [1, TimedRedSet.score("somekey", 1)]
+      ]
+    end
+
+    it "supports pagination" do
+      TimedRedSet.add("somekey", 1)
+      TimedRedSet.add("somekey", 2)
+      TimedRedSet.add("somekey", 3)
+
+      TimedRedSet.get_with_timestamps("somekey", :lower => 0, :upper => 0).should == [
+        [3, TimedRedSet.score("somekey", 3)]
+      ]
+    end
+  end
+end

data/spec/spec_integration_helper.rb

@@ -0,0 +1,48 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rspec'
+require 'redis'
+require 'active_support/core_ext'
+require 'timecop'
+
+require 'redis_runner'
+require 'precisionable'
+
+require 'redness'
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    print "Starting Redis..."
+
+    RedisRunner.start
+
+    attempts = 10
+
+    until RedisRunner.up? or attempts <= 0
+      sleep 1
+      attempts -= 1
+    end
+
+    if RedisRunner.up? 
+      puts " OK"
+    else
+      puts " FAIL"
+    end
+
+    $redis = Redis.new(
+      host: RedisRunner.host,
+      port: RedisRunner.port,
+      thread_safe: true
+    )
+  end
+
+  config.after(:suite) do
+    RedisRunner.stop
+  end
+
+  config.after(:each) do
+    Timecop.return
+    $redis.flushall
+  end
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: redness
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Baldur
+- Gudbjornsson
+- Matt
+- Vermaak
+- Bryan
+- Woods
+- Kenneth
+- Lay
+- Marco
+- Carag
+- Conner
+- Peirce
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-13 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70292141275900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70292141275900
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: &70292141296880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *70292141296880
+- !ruby/object:Gem::Dependency
+  name: active_support
+  requirement: &70292141296460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70292141296460
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: &70292141296000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70292141296000
+description: Helpful Ruby classes for improved Redis data structures
+email: dev@howaboutwe.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- LICENSE.txt
+- RAKEFILE
+- README.rdoc
+- lib/redness.rb
+- lib/redness/red.rb
+- lib/redness/red_capped_list.rb
+- lib/redness/red_expire.rb
+- lib/redness/red_hash.rb
+- lib/redness/red_json.rb
+- lib/redness/red_list.rb
+- lib/redness/red_set.rb
+- lib/redness/red_set_multi.rb
+- lib/redness/red_set_union.rb
+- lib/redness/timed_red_set.rb
+- lib/version.rb
+- redness.gemspec
+- spec/precisionable.rb
+- spec/redis_runner.rb
+- spec/redness/red_capped_list_spec.rb
+- spec/redness/red_expire_spec.rb
+- spec/redness/red_hash_spec.rb
+- spec/redness/red_json_spec.rb
+- spec/redness/red_list_spec.rb
+- spec/redness/red_set_multi_spec.rb
+- spec/redness/red_set_spec.rb
+- spec/redness/red_set_union_spec.rb
+- spec/redness/timed_red_set_spec.rb
+- spec/spec_integration_helper.rb
+homepage: http://github.com/howaboutwe/redness
+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'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.16
+signing_key: 
+specification_version: 3
+summary: Helpful Ruby classes for improved Redis data structures
+test_files: []