redis_recipes 0.3.0

data/redis_recipes.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.required_ruby_version = '>= 1.9.0'
+  s.required_rubygems_version = ">= 1.3.6"
+
+  s.name        = "redis_recipes"
+  s.summary     = "Redis LUA recipes."
+  s.description = "Require Redis 2.6.0 or higher"
+  s.version     = "0.3.0"
+
+  s.authors     = ["Black Square Media"]
+  s.email       = "info@blacksquaremedia.com"
+  s.homepage    = "https://github.com/bsm/redis_recipes"
+
+  s.require_path = ['lib']
+  s.files        = `git ls-files`.split("\n")
+  s.test_files   = `git ls-files -- spec/*`.split("\n")
+
+  s.add_development_dependency "redis", "~> 3.0.0"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+end

data/spec/range_lookup/add_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+describe "Range Lookup: Adding" do
+
+  def state(c = :to_i)
+    ranges = {}
+    redis.zrange('my_store:~', 0, -1, with_scores: true).each do |value, score|
+      ranges[score.send(c)] = redis.smembers("my_store:#{value}").sort.join
+    end
+    ranges
+  end
+
+  def add(member, min, max)
+    evalsha :add, keys: ["my_store"], argv: [member, min, max]
+  end
+
+  describe "general" do
+
+    it 'should catch invalid arguments' do
+      lambda { evalsha :add }.should raise_error(Redis::CommandError, /wrong number of arguments/)
+      lambda { evalsha :add, keys: ["one"] }.should raise_error(Redis::CommandError, /wrong number of arguments/)
+      lambda { evalsha :add, keys: ["one"], argv: ["one", 2] }.should raise_error(Redis::CommandError, /wrong number of arguments/)
+      lambda { evalsha :add, keys: ["one", "two"], argv: ["one", 2, 3] }.should raise_error(Redis::CommandError, /wrong number of arguments/)
+    end
+
+    it 'should catch non-numeric ranges' do
+      lambda { evalsha :add, keys: ["one"], argv: ["one", "two", 3] }.should raise_error(Redis::CommandError, /not numeric or out of range/)
+      lambda { evalsha :add, keys: ["one"], argv: ["one", 2, "three"] }.should raise_error(Redis::CommandError, /not numeric or out of range/)
+      lambda { evalsha :add, keys: ["one"], argv: ["one", 3, 2] }.should raise_error(Redis::CommandError, /not numeric or out of range/)
+    end
+
+  end
+
+  describe "adding" do
+    before { add("A", 8, 17) }
+
+    it 'should support single-value ranges' do
+      lambda { add("B", 10, 10) }.should change { state }.
+        to 8 => "A", 10 => "AB", 17 => "A"
+    end
+
+    it 'should support float/decimal ranges' do
+      lambda { add("B", 10, 10.5) }.should change { state(:to_f) }.
+        to 8.0 => "A", 10.0 => "AB", 10.5 => "AB", 17.0 => "A"
+    end
+
+    it 'should support zero bounds' do
+      lambda { add("B", 0, 5) }.should change { state }.
+        to 0 => "B", 5 => "B", 8 => "A", 17 => "A"
+
+      lambda { add("C", -5, 0) }.should change { state }.
+        to -5 => "C", 0 => "BC", 5 => "B", 8 => "A", 17 => "A"
+    end
+
+    it 'should maintain an index' do
+      redis.zrange('my_store:~', 0, -1, with_scores: true).should == [["8", 8], ["17", 17]]
+    end
+
+    it 'should store range values' do
+      redis.keys.should =~ ["my_store:~", "my_store:8", "my_store:17"]
+      state.should == { 8 => "A", 17 => "A" }
+    end
+
+    it 'should return OK if successful' do
+      add("B", 9, 18).should == "OK"
+    end
+
+  end
+
+  describe "merging" do
+    before { add("A", 8, 17) }
+
+    it 'should add non overlapping, left (B B A A)' do
+      lambda { add("B", 5, 6) }.should change { state }.
+        to 5 => "B", 6 => "B", 8 => "A", 17 => "A"
+    end
+
+    it 'should add non overlapping, right (A A B B)' do
+      lambda { add("B", 18, 23) }.should change { state }.
+        to 8 => "A", 17 => "A", 18 => "B", 23 => "B"
+    end
+
+    it 'should add non overlapping, inner (A B B A)' do
+      lambda { add("B", 9, 12) }.should change { state }.
+        to 8 => "A", 9 => "AB", 12 => "AB", 17 => "A"
+    end
+
+    it 'should add overlapping, left (B A B A)' do
+      lambda { add("B", 6, 10) }.should change { state }.
+        to 6 => "B", 8 => "AB", 10 => "AB", 17 => "A"
+    end
+
+    it 'should add overlapping, right (A B A B)' do
+      lambda { add("B", 15, 23) }.should change { state }.
+        to 8 => "A", 15 => "AB", 17 => "AB", 23 => "B"
+    end
+
+    it 'should add overlapping, both (AB BA)' do
+      lambda { add("B", 8, 17) }.should change { state }.
+        to 8 => "AB", 17 => "AB"
+    end
+
+    it 'should add tangent, outer left (B BA A)' do
+      lambda { add("B", 6, 8) }.should change { state }.
+        to 6 => "B", 8 => "AB",  17 => "A"
+    end
+
+    it 'should add tangent, inner left (AB B A)' do
+      lambda { add("B", 8, 10) }.should change { state }.
+        to 8 => "AB", 10 => "AB",  17 => "A"
+    end
+
+    it 'should add tangent, outer right (A AB B)' do
+      lambda { add("B", 17, 22) }.should change { state }.
+        to 8 => "A", 17 => "AB", 22 => "B"
+    end
+
+    it 'should add tangent, inner right (A B BA)' do
+      lambda { add("B", 12, 17) }.should change { state }.
+        to 8 => "A", 12 => "AB", 17 => "AB"
+    end
+
+  end
+
+  it 'should bring it all together' do
+    add("A",  8, 17)
+    add("B",  5,  6)
+    add("C", 18, 23)
+    add("D",  9, 12)
+    add("E",  6, 10)
+    add("F", 15, 23)
+    add("G",  8, 17)
+    add("H",  6,  8)
+    add("I",  8, 10)
+    add("J",  7, 22)
+    add("K", 12, 17)
+
+    state.should == {
+       5 => "B",       6 => "BEH",     7 => "EHJ",
+       8 => "AEGHIJ",  9 => "ADEGIJ", 10 => "ADEGIJ",
+      12 => "ADGJK",  15 => "AFGJK",  17 => "AFGJK",
+      18 => "CFJ",    22 => "CFJ",    23 => "CF"
+    }
+  end
+
+end

data/spec/range_lookup/lookup_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe "Range Lookup: Lookup" do
+
+  def add(member, min, max)
+    evalsha :add, keys: ["my_store"], argv: [member, min, max]
+  end
+
+  def lookup(value)
+    evalsha :lookup, keys: ["my_store"], argv: [value]
+  end
+
+  before do
+    add("A", 0, 8)
+    add("B", 4, 6)
+    add("C", 2, 9)
+    add("D", 7, 10)
+  end
+
+  def state
+    ranges = {}
+    redis.zrange('my_store:~', 0, -1, with_scores: true).each do |value, score|
+      ranges[score.to_f] = redis.smembers("my_store:#{value}").sort
+    end
+    ranges
+  end
+
+  it 'should catch invalid arguments' do
+    lambda { evalsha :lookup }.should raise_error(Redis::CommandError, /wrong number of arguments/)
+    lambda { evalsha :lookup, keys: ["one"] }.should raise_error(Redis::CommandError, /wrong number of arguments/)
+    lambda { evalsha :lookup, keys: ["one"], argv: ["one", 2] }.should raise_error(Redis::CommandError, /wrong number of arguments/)
+  end
+
+  it 'should catch non-numeric ranges' do
+    lambda { evalsha :lookup, keys: ["one"], argv: ["one"] }.should raise_error(Redis::CommandError, /not numeric or out of range/)
+  end
+
+  it 'should return the members when found' do
+    lookup(0).should  =~ ["A"]
+    lookup(1).should  =~ ["A"]
+    lookup(2).should  =~ ["A", "C"]
+    lookup(3).should  =~ ["A", "C"]
+    lookup(4).should  =~ ["A", "B", "C"]
+    lookup(5).should  =~ ["A", "B", "C"]
+    lookup(6).should  =~ ["A", "B", "C"]
+    lookup(7).should  =~ ["A", "C", "D"]
+    lookup(8).should  =~ ["A", "C", "D"]
+    lookup(9).should  =~ ["C", "D"]
+    lookup(10).should =~ ["D"]
+  end
+
+  it 'should return an empty set if not found' do
+    lookup(-1).should  =~ []
+    lookup(11).should  =~ []
+    lookup(111).should  =~ []
+  end
+
+  it 'should support float lookups' do
+    lookup(6.5).should  =~ ["A", "C"]
+    lookup(7.5).should  =~ ["A", "C", "D"]
+    lookup(10.1).should =~ []
+  end
+
+end

data/spec/range_lookup/remove_spec.rb

@@ -0,0 +1,189 @@
+require 'spec_helper'
+
+describe "Range Lookup: Removing" do
+
+  def state(c = :to_i)
+    ranges = {}
+    redis.zrange('my_store:~', 0, -1, with_scores: true).each do |value, score|
+      ranges[score.send(c)] = redis.smembers("my_store:#{value}").sort.join
+    end
+    ranges
+  end
+
+  def brackets
+    redis.zrange('my_store:~', 0, -1)
+  end
+
+  def add(member, min, max)
+    evalsha :add, keys: ["my_store"], argv: [member, min, max]
+  end
+
+  def remove(member, min, max)
+    evalsha :remove, keys: ["my_store"], argv: [member, min, max]
+  end
+
+  def scenario(pairs)
+    pairs.each do |member, range|
+      add member.to_s, range.first, range.last
+    end
+  end
+
+  describe "general" do
+
+    it 'should catch invalid arguments' do
+      lambda { evalsha :remove }.should raise_error(Redis::CommandError, /wrong number of arguments/)
+      lambda { evalsha :remove, keys: ["one"] }.should raise_error(Redis::CommandError, /wrong number of arguments/)
+      lambda { evalsha :remove, keys: ["one"], argv: ["one", 2] }.should raise_error(Redis::CommandError, /wrong number of arguments/)
+      lambda { evalsha :remove, keys: ["one", "two"], argv: ["one", 2, 3] }.should raise_error(Redis::CommandError, /wrong number of arguments/)
+    end
+
+    it 'should catch non-numeric ranges' do
+      lambda { evalsha :remove, keys: ["one"], argv: ["one", "two", 3] }.should raise_error(Redis::CommandError, /not numeric or out of range/)
+      lambda { evalsha :remove, keys: ["one"], argv: ["one", 2, "three"] }.should raise_error(Redis::CommandError, /not numeric or out of range/)
+      lambda { evalsha :remove, keys: ["one"], argv: ["one", 3, 2] }.should raise_error(Redis::CommandError, /not numeric or out of range/)
+    end
+
+    it 'should return OK if successful' do
+      remove("A", 8, 17).should == "OK"
+    end
+
+  end
+
+  describe "removing" do
+    before { add("A", 8, 17) }
+
+    it 'should support zero bounds' do
+      scenario B: -5..0, C: 0..5
+
+      lambda {
+        remove("B", -5, 0)
+        remove("C", 0, 5)
+      }.should change { state }.
+        from(-5 => "B", 0 => "BC", 5 => "C", 8 => "A", 17 => "A").
+        to(8 => "A", 17 => "A")
+    end
+
+    it 'should clean up index' do
+      lambda {
+        add("B", 15, 22)
+        add("C", 15, 23)
+      }.should change { brackets }.to ["8", "15", "17", "22", "23"]
+
+      lambda {
+        remove("B", 15, 22)
+      }.should change { brackets }.to ["8", "15", "17", "23"]
+
+      lambda {
+        remove("C", 15, 23)
+      }.should change { brackets }.to ["8", "17"]
+
+      lambda {
+        remove("A", 8, 17)
+      }.should change { brackets }.to []
+    end
+
+  end
+
+  describe "use cases" do
+
+    it "should remove from [A: 1-2, B: 3-4]" do
+      scenario A: 1..2, B: 3..4
+      lambda { remove("A", 1, 2) }.should change { state }.
+        from(1 => "A", 2 => "A", 3 => "B", 4 => "B").
+        to(3 => "B", 4 => "B")
+    end
+
+    it "should remove from [A: 3-4, B: 1-2]" do      
+      scenario A: 3..4, B: 1..2
+      lambda { remove("A", 3, 4) }.should change { state }.
+        from(1 => "B", 2 => "B", 3 => "A", 4 => "A").
+        to(1 => "B", 2 => "B")
+    end
+
+    it "should remove from [A: 1-3, B: 2-4]" do
+      scenario A: 1..3, B: 2..4
+      lambda { remove("A", 1, 3) }.should change { state }.
+        from(1 => "A", 2 => "AB", 3 => "AB", 4 => "B").
+        to(2 => "B", 4 => "B")
+    end
+
+    it "should remove from [A: 2-4, B: 1-3]" do
+      scenario A: 2..4, B: 1..3
+      lambda { remove("A", 2, 4) }.should change { state }.
+        from(1 => "B", 2 => "AB", 3 => "AB", 4 => "A").
+        to(1 => "B", 3 => "B")
+    end
+
+    it "should remove from [A: 1-4, B: 2-3]" do
+      scenario A: 1..4, B: 2..3
+      lambda { remove("A", 1, 4) }.should change { state }.
+        from(1 => "A", 2 => "AB", 3 => "AB", 4 => "A").
+        to(2 => "B", 3 => "B")
+    end
+
+    it "should remove from [A: 2-3, B: 1-4]" do
+      scenario A: 2..3, B: 1..4
+      lambda { remove("A", 2, 3) }.should change { state }.
+        from(1 => "B", 2 => "AB", 3 => "AB", 4 => "B").
+        to(1 => "B", 4 => "B")
+    end
+
+    it "should remove from [A: 1-3, B: 3-4]" do
+      scenario A: 1..3, B: 3..4
+      lambda { remove("A", 1, 3) }.should change { state }.
+        from(1 => "A", 3 => "AB", 4 => "B").
+        to(3 => "B", 4 => "B")
+    end
+
+    it "should remove from [A: 1-4, B: 3-4]" do
+      scenario A: 1..4, B: 3..4
+      lambda { remove("A", 1, 4) }.should change { state }.
+        from(1 => "A", 3 => "AB", 4 => "AB").
+        to(3 => "B", 4 => "B")
+    end
+
+    it "should remove from [A: 3-4, B: 1-3]" do
+      scenario A: 3..4, B: 1..3
+      lambda { remove("A", 3, 4) }.should change { state }.
+        from(1 => "B", 3 => "AB", 4 => "A").
+        to(1 => "B", 3 => "B")
+    end
+
+    it "should remove from [A: 3-4, B: 1-4]" do
+      scenario A: 3..4, B: 1..4
+      lambda { remove("A", 3, 4) }.should change { state }.
+        from(1 => "B", 3 => "AB", 4 => "AB").
+        to(1 => "B", 4 => "B")
+    end
+
+    it "should remove from [A: 1-4, B: 1-2]" do
+      scenario A: 1..4, B: 1..2
+      lambda { remove("A", 1, 4) }.should change { state }.
+        from(1 => "AB", 2 => "AB", 4 => "A").
+        to(1 => "B", 2 => "B")
+    end
+
+    it "should remove from [A: 2-4, B: 1-2]" do
+      scenario A: 2..4, B: 1..2
+      lambda { remove("A", 2, 4) }.should change { state }.
+        from(1 => "B", 2 => "AB", 4 => "A").
+        to(1 => "B", 2 => "B")
+    end
+
+    it "should remove from [A: 1-4, B: 1-4]" do
+      scenario A: 1..4, B: 1..4
+      lambda { remove("A", 1, 4) }.should change { state }.
+        from(1 => "AB", 4 => "AB").
+        to(1 => "B", 4 => "B")
+    end
+
+    it "should remove from [A: 1-4]" do
+      scenario A: 1..4
+      lambda { remove("A", 1, 4) }.should change { state }.
+        from(1 => "A", 4 => "A").
+        to({})
+    end
+
+  end
+
+end

data/spec/range_lookup_x/add_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+describe "Range Lookup X: Adding" do
+
+  def state(c = :to_i)
+    ranges = {}
+    redis.zrange('my_store:~', 0, -1, with_scores: true).each do |value, score|
+      ranges[score.send(c)] = redis.smembers("my_store:#{value}").sort.join
+    end
+    ranges
+  end
+
+  def add(member, min, max)
+    evalsha :add, keys: ["my_store"], argv: [member, min, max]
+  end
+
+  describe "general" do
+  
+    it 'should catch invalid arguments' do
+      lambda { evalsha :add }.should raise_error(Redis::CommandError, /wrong number of arguments/)
+      lambda { evalsha :add, keys: ["one"] }.should raise_error(Redis::CommandError, /wrong number of arguments/)
+      lambda { evalsha :add, keys: ["one"], argv: ["one", 2] }.should raise_error(Redis::CommandError, /wrong number of arguments/)
+      lambda { evalsha :add, keys: ["one", "two"], argv: ["one", 2, 3] }.should raise_error(Redis::CommandError, /wrong number of arguments/)
+    end
+
+    it 'should catch non-numeric ranges' do
+      lambda { evalsha :add, keys: ["one"], argv: ["one", "two", 3] }.should raise_error(Redis::CommandError, /not numeric or out of range/)
+      lambda { evalsha :add, keys: ["one"], argv: ["one", 2, "three"] }.should raise_error(Redis::CommandError, /not numeric or out of range/)
+      lambda { evalsha :add, keys: ["one"], argv: ["one", 3, 2] }.should raise_error(Redis::CommandError, /not numeric or out of range/)
+    end
+
+    it 'should NOT support single-value ranges' do
+      lambda { add("B", 10, 10) }.should raise_error(Redis::CommandError, /not numeric or out of range/)
+    end
+
+  end
+
+  describe "adding" do
+
+    it 'should store ranges' do      
+      lambda { add("A", 8, 17) }.should change { state }.
+        to 8 => "A", 17 => ""
+    end
+
+    it 'should support float/decimal ranges' do      
+      lambda { add("A", 7.5, 17.9); add("B", 8.1, 10.6) }.should change { state(:to_f) }.
+        to 7.5 => "A", 8.1 => "AB", 10.6 => "A", 17.9 => ""
+    end
+
+    it 'should support nagative ranges and bounds' do
+      lambda { add("B", 0, 5) }.should change { state }.
+        to 0 => "B", 5 => ""
+
+      lambda { add("C", -5, 0) }.should change { state }.
+        to -5 => "C", 0 => "B", 5 => ""
+    end
+
+    it 'should maintain an index' do
+      lambda { add("A", 8, 17) }.should change { 
+        redis.zrange('my_store:~', 0, -1, with_scores: true)
+      }.to [["8", 8.0], ["17", 17.0]]
+    end
+
+    it 'should store range members' do
+      lambda { add("A", 8, 17) }.should change { redis.keys.sort }.
+        to ["my_store:8", "my_store:~"]
+    end
+
+    it 'should return OK if successful' do
+      add("A", 8, 17).should == "OK"
+    end
+
+  end
+
+  describe "merging" do
+    before { add("A", 8, 17) }
+
+    it 'should add non overlapping, left (B B A A)' do
+      lambda { add("B", 5, 6) }.should change { state }.
+        to 5 => "B", 6 => "", 8 => "A", 17 => ""
+    end
+
+    it 'should add non overlapping, right (A A B B)' do
+      lambda { add("B", 18, 23) }.should change { state }.
+        to 8 => "A", 17 => "", 18 => "B", 23 => ""
+    end
+
+    it 'should add non overlapping, inner (A B B A)' do
+      lambda { add("B", 9, 12) }.should change { state }.
+        to 8 => "A", 9 => "AB", 12 => "A", 17 => ""
+    end
+
+    it 'should add overlapping, left (B A B A)' do
+      lambda { add("B", 6, 10) }.should change { state }.
+        to 6 => "B", 8 => "AB", 10 => "A", 17 => ""
+    end
+
+    it 'should add overlapping, right (A B A B)' do
+      lambda { add("B", 15, 23) }.should change { state }.
+        to 8 => "A", 15 => "AB", 17 => "B", 23 => ""
+    end
+
+    it 'should add overlapping, both (AB BA)' do
+      lambda { add("B", 8, 17) }.should change { state }.
+        to 8 => "AB", 17 => ""
+    end
+
+    it 'should add tangent, outer left (B BA A)' do
+      lambda { add("B", 6, 8) }.should change { state }.
+        to 6 => "B", 8 => "A",  17 => ""
+    end
+
+    it 'should add tangent, inner left (AB B A)' do
+      lambda { add("B", 8, 10) }.should change { state }.
+        to 8 => "AB", 10 => "A",  17 => ""
+    end
+
+    it 'should add tangent, outer right (A AB B)' do
+      lambda { add("B", 17, 22) }.should change { state }.
+        to 8 => "A", 17 => "B", 22 => ""
+    end
+
+    it 'should add tangent, inner right (A B BA)' do
+      lambda { add("B", 12, 17) }.should change { state }.
+        to 8 => "A", 12 => "AB", 17 => ""
+    end
+
+    it 'should work with multiple ranges' do
+      add("B",  5,  6)
+      add("C", 18, 23)
+      add("D",  9, 12)
+      add("E",  6, 10)
+      add("F", 15, 23)
+      add("G",  8, 17)
+      add("H",  6,  8)
+      add("I",  8, 10)
+      add("J",  7, 22)
+      add("K", 12, 17)
+
+      state.should == {
+         5 => "B",       6 => "EH",      7 => "EHJ",
+         8 => "AEGIJ",   9 => "ADEGIJ", 10 => "ADGJ",
+        12 => "AGJK",   15 => "AFGJK",  17 => "FJ",
+        18 => "CFJ",    22 => "CF",     23 => ""
+      }
+    end
+  end
+
+end