modesty 0.1.0

data/vendor/redis-rb/lib/redis/hash_ring.rb

@@ -0,0 +1,131 @@
+require 'zlib'
+
+class Redis
+  class HashRing
+
+    POINTS_PER_SERVER = 160 # this is the default in libmemcached
+
+    attr_reader :ring, :sorted_keys, :replicas, :nodes
+
+    # nodes is a list of objects that have a proper to_s representation.
+    # replicas indicates how many virtual points should be used pr. node,
+    # replicas are required to improve the distribution.
+    def initialize(nodes=[], replicas=POINTS_PER_SERVER)
+      @replicas = replicas
+      @ring = {}
+      @nodes = []
+      @sorted_keys = []
+      nodes.each do |node|
+        add_node(node)
+      end
+    end
+
+    # Adds a `node` to the hash ring (including a number of replicas).
+    def add_node(node)
+      @nodes << node
+      @replicas.times do |i|
+        key = Zlib.crc32("#{node.id}:#{i}")
+        @ring[key] = node
+        @sorted_keys << key
+      end
+      @sorted_keys.sort!
+    end
+
+    def remove_node(node)
+      @nodes.reject!{|n| n.id == node.id}
+      @replicas.times do |i|
+        key = Zlib.crc32("#{node.id}:#{i}")
+        @ring.delete(key)
+        @sorted_keys.reject! {|k| k == key}
+      end
+    end
+
+    # get the node in the hash ring for this key
+    def get_node(key)
+      get_node_pos(key)[0]
+    end
+
+    def get_node_pos(key)
+      return [nil,nil] if @ring.size == 0
+      crc = Zlib.crc32(key)
+      idx = HashRing.binary_search(@sorted_keys, crc)
+      return [@ring[@sorted_keys[idx]], idx]
+    end
+
+    def iter_nodes(key)
+      return [nil,nil] if @ring.size == 0
+      node, pos = get_node_pos(key)
+      @sorted_keys[pos..-1].each do |k|
+        yield @ring[k]
+      end
+    end
+
+    class << self
+
+      # gem install RubyInline to use this code
+      # Native extension to perform the binary search within the hashring.
+      # There's a pure ruby version below so this is purely optional
+      # for performance.  In testing 20k gets and sets, the native
+      # binary search shaved about 12% off the runtime (9sec -> 8sec).
+      begin
+        require 'inline'
+        inline do |builder|
+          builder.c <<-EOM
+          int binary_search(VALUE ary, unsigned int r) {
+              int upper = RARRAY_LEN(ary) - 1;
+              int lower = 0;
+              int idx = 0;
+
+              while (lower <= upper) {
+                  idx = (lower + upper) / 2;
+
+                  VALUE continuumValue = RARRAY_PTR(ary)[idx];
+                  unsigned int l = NUM2UINT(continuumValue);
+                  if (l == r) {
+                      return idx;
+                  }
+                  else if (l > r) {
+                      upper = idx - 1;
+                  }
+                  else {
+                      lower = idx + 1;
+                  }
+              }
+              if (upper < 0) {
+                upper = RARRAY_LEN(ary) - 1;
+              }
+              return upper;
+          }
+          EOM
+        end
+      rescue Exception => e
+        # Find the closest index in HashRing with value <= the given value
+        def binary_search(ary, value, &block)
+          upper = ary.size - 1
+          lower = 0
+          idx = 0
+
+          while(lower <= upper) do
+            idx = (lower + upper) / 2
+            comp = ary[idx] <=> value
+
+            if comp == 0
+              return idx
+            elsif comp > 0
+              upper = idx - 1
+            else
+              lower = idx + 1
+            end
+          end
+
+          if upper < 0
+            upper = ary.size - 1
+          end
+          return upper
+        end
+
+      end
+    end
+
+  end
+end

data/vendor/redis-rb/lib/redis/pipeline.rb

@@ -0,0 +1,13 @@
+class Redis
+  class Pipeline
+    attr :commands
+
+    def initialize
+      @commands = []
+    end
+
+    def call(*args)
+      @commands << args
+    end
+  end
+end

data/vendor/redis-rb/lib/redis/subscribe.rb

@@ -0,0 +1,79 @@
+class Redis
+  class SubscribedClient
+    def initialize(client)
+      @client = client
+    end
+
+    def call(*args)
+      @client.process(args)
+    end
+
+    def subscribe(*channels, &block)
+      subscription("subscribe", "unsubscribe", channels, block)
+    end
+
+    def psubscribe(*channels, &block)
+      subscription("psubscribe", "punsubscribe", channels, block)
+    end
+
+    def unsubscribe(*channels)
+      call(:unsubscribe, *channels)
+    end
+
+    def punsubscribe(*channels)
+      call(:punsubscribe, *channels)
+    end
+
+  protected
+
+    def subscription(start, stop, channels, block)
+      sub = Subscription.new(&block)
+
+      begin
+        @client.call_loop(start, *channels) do |line|
+          type, *rest = line
+          sub.callbacks[type].call(*rest)
+          break if type == stop && rest.last == 0
+        end
+      ensure
+        send(stop)
+      end
+    end
+  end
+
+  class Subscription
+    attr :callbacks
+
+    def initialize
+      @callbacks = Hash.new do |hash, key|
+        hash[key] = lambda { |*_| }
+      end
+
+      yield(self)
+    end
+
+    def subscribe(&block)
+      @callbacks["subscribe"] = block
+    end
+
+    def unsubscribe(&block)
+      @callbacks["unsubscribe"] = block
+    end
+
+    def message(&block)
+      @callbacks["message"] = block
+    end
+
+    def psubscribe(&block)
+      @callbacks["psubscribe"] = block
+    end
+
+    def punsubscribe(&block)
+      @callbacks["punsubscribe"] = block
+    end
+
+    def pmessage(&block)
+      @callbacks["pmessage"] = block
+    end
+  end
+end

data/vendor/redis-rb/redis.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{redis}
+  s.version = "2.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ezra Zygmuntowicz", "Taylor Weibley", "Matthew Clark", "Brian McKinney", "Salvatore Sanfilippo", "Luca Guidi", "Michel Martens", "Damian Janowski"]
+  s.autorequire = %q{redis}
+  s.date = %q{2010-11-05}
+  s.description = %q{Ruby client library for Redis, the key value storage server}
+  s.email = %q{ez@engineyard.com}
+  s.extra_rdoc_files = ["LICENSE"]
+  s.files = ["LICENSE", "README.markdown", "Rakefile", "lib/redis", "lib/redis/client.rb", "lib/redis/compat.rb", "lib/redis/connection.rb", "lib/redis/distributed.rb", "lib/redis/hash_ring.rb", "lib/redis/pipeline.rb", "lib/redis/subscribe.rb", "lib/redis.rb"]
+  s.homepage = %q{http://github.com/ezmobius/redis-rb}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Ruby client library for Redis, the key value storage server}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/vendor/redis-rb/test/commands_on_hashes_test.rb

@@ -0,0 +1,46 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+setup do
+  init Redis.new(OPTIONS)
+end
+
+load './test/lint/hashes.rb'
+
+test "HSETNX" do |r|
+  r.hset("foo", "f1", "s1")
+  r.hsetnx("foo", "f1", "s2")
+
+  assert "s1" == r.hget("foo", "f1")
+
+  r.del("foo")
+  r.hsetnx("foo", "f1", "s2")
+
+  assert "s2" == r.hget("foo", "f1")
+end
+
+test "HMGET" do |r|
+  r.hset("foo", "f1", "s1")
+  r.hset("foo", "f2", "s2")
+  r.hset("foo", "f3", "s3")
+
+  assert ["s2", "s3"] == r.hmget("foo", "f2", "f3")
+end
+
+test "HMGET mapped" do |r|
+  r.hset("foo", "f1", "s1")
+  r.hset("foo", "f2", "s2")
+  r.hset("foo", "f3", "s3")
+
+  assert({"f1" => "s1"} == r.mapped_hmget("foo", "f1"))
+  assert({"f1" => "s1", "f2" => "s2"} == r.mapped_hmget("foo", "f1", "f2"))
+end
+
+test "Mapped HMSET" do |r|
+  r.mapped_hmset("foo", :f1 => "s1", :f2 => "s2")
+
+  assert "s1" == r.hget("foo", "f1")
+  assert "s2" == r.hget("foo", "f2")
+end
+

data/vendor/redis-rb/test/commands_on_lists_test.rb

@@ -0,0 +1,50 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+setup do
+  init Redis.new(OPTIONS)
+end
+
+load './test/lint/lists.rb'
+
+test "RPUSHX" do |r|
+  r.rpushx "foo", "s1"
+  r.rpush "foo", "s2"
+  r.rpushx "foo", "s3"
+
+  assert 2 == r.llen("foo")
+  assert ["s2", "s3"] == r.lrange("foo", 0, -1)
+end
+
+test "LPUSHX" do |r|
+  r.lpushx "foo", "s1"
+  r.lpush "foo", "s2"
+  r.lpushx "foo", "s3"
+
+  assert 2 == r.llen("foo")
+  assert ["s3", "s2"] == r.lrange("foo", 0, -1)
+end
+
+test "LINSERT" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s3"
+  r.linsert "foo", :before, "s3", "s2"
+
+  assert ["s1", "s2", "s3"] == r.lrange("foo", 0, -1)
+
+  assert_raise(RuntimeError) do
+    r.linsert "foo", :anywhere, "s3", "s2"
+  end
+end
+
+test "RPOPLPUSH" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+
+  assert "s2" == r.rpoplpush("foo", "bar")
+  assert ["s2"] == r.lrange("bar", 0, -1)
+  assert "s1" == r.rpoplpush("foo", "bar")
+  assert ["s1", "s2"] == r.lrange("bar", 0, -1)
+end
+

data/vendor/redis-rb/test/commands_on_sets_test.rb

@@ -0,0 +1,78 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+setup do
+  init Redis.new(OPTIONS)
+end
+
+load './test/lint/sets.rb'
+
+test "SMOVE" do |r|
+  r.sadd "foo", "s1"
+  r.sadd "bar", "s2"
+
+  assert r.smove("foo", "bar", "s1")
+  assert r.sismember("bar", "s1")
+end
+
+test "SINTER" do |r|
+  r.sadd "foo", "s1"
+  r.sadd "foo", "s2"
+  r.sadd "bar", "s2"
+
+  assert ["s2"] == r.sinter("foo", "bar")
+end
+
+test "SINTERSTORE" do |r|
+  r.sadd "foo", "s1"
+  r.sadd "foo", "s2"
+  r.sadd "bar", "s2"
+
+  r.sinterstore("baz", "foo", "bar")
+
+  assert ["s2"] == r.smembers("baz")
+end
+
+test "SUNION" do |r|
+  r.sadd "foo", "s1"
+  r.sadd "foo", "s2"
+  r.sadd "bar", "s2"
+  r.sadd "bar", "s3"
+
+  assert ["s1", "s2", "s3"] == r.sunion("foo", "bar").sort
+end
+
+test "SUNIONSTORE" do |r|
+  r.sadd "foo", "s1"
+  r.sadd "foo", "s2"
+  r.sadd "bar", "s2"
+  r.sadd "bar", "s3"
+
+  r.sunionstore("baz", "foo", "bar")
+
+  assert ["s1", "s2", "s3"] == r.smembers("baz").sort
+end
+
+test "SDIFF" do |r|
+  r.sadd "foo", "s1"
+  r.sadd "foo", "s2"
+  r.sadd "bar", "s2"
+  r.sadd "bar", "s3"
+
+  assert ["s1"] == r.sdiff("foo", "bar")
+  assert ["s3"] == r.sdiff("bar", "foo")
+end
+
+test "SDIFFSTORE" do |r|
+  r.sadd "foo", "s1"
+  r.sadd "foo", "s2"
+  r.sadd "bar", "s2"
+  r.sadd "bar", "s3"
+
+  r.sdiffstore("baz", "foo", "bar")
+
+  assert ["s1"] == r.smembers("baz")
+end
+
+

data/vendor/redis-rb/test/commands_on_sorted_sets_test.rb

@@ -0,0 +1,109 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+setup do
+  init Redis.new(OPTIONS)
+end
+
+load './test/lint/sorted_sets.rb'
+
+test "ZCOUNT" do |r|
+  r.zadd "foo", 1, "s1"
+  r.zadd "foo", 2, "s2"
+  r.zadd "foo", 3, "s3"
+
+  assert 2 == r.zcount("foo", 2, 3)
+end
+
+test "ZUNIONSTORE" do |r|
+  r.zadd "foo", 1, "s1"
+  r.zadd "bar", 2, "s2"
+  r.zadd "foo", 3, "s3"
+  r.zadd "bar", 4, "s4"
+
+  assert 4 == r.zunionstore("foobar", ["foo", "bar"])
+  assert ["s1", "s2", "s3", "s4"] == r.zrange("foobar", 0, -1)
+end
+
+test "ZUNIONSTORE with WEIGHTS" do |r|
+  r.zadd "foo", 1, "s1"
+  r.zadd "foo", 3, "s3"
+  r.zadd "bar", 20, "s2"
+  r.zadd "bar", 40, "s4"
+
+  assert 4 == r.zunionstore("foobar", ["foo", "bar"])
+  assert ["s1", "s3", "s2", "s4"] == r.zrange("foobar", 0, -1)
+
+  assert 4 == r.zunionstore("foobar", ["foo", "bar"], :weights => [10, 1])
+  assert ["s1", "s2", "s3", "s4"] == r.zrange("foobar", 0, -1)
+end
+
+test "ZUNIONSTORE with AGGREGATE" do |r|
+  r.zadd "foo", 1, "s1"
+  r.zadd "foo", 2, "s2"
+  r.zadd "bar", 4, "s2"
+  r.zadd "bar", 3, "s3"
+
+  assert 3 == r.zunionstore("foobar", ["foo", "bar"])
+  assert ["s1", "s3", "s2"] == r.zrange("foobar", 0, -1)
+
+  assert 3 == r.zunionstore("foobar", ["foo", "bar"], :aggregate => :min)
+  assert ["s1", "s2", "s3"] == r.zrange("foobar", 0, -1)
+
+  assert 3 == r.zunionstore("foobar", ["foo", "bar"], :aggregate => :max)
+  assert ["s1", "s3", "s2"] == r.zrange("foobar", 0, -1)
+end
+
+test "ZINTERSTORE" do |r|
+  r.zadd "foo", 1, "s1"
+  r.zadd "bar", 2, "s1"
+  r.zadd "foo", 3, "s3"
+  r.zadd "bar", 4, "s4"
+
+  assert 1 == r.zinterstore("foobar", ["foo", "bar"])
+  assert ["s1"] == r.zrange("foobar", 0, -1)
+end
+
+test "ZINTERSTORE with WEIGHTS" do |r|
+  r.zadd "foo", 1, "s1"
+  r.zadd "foo", 2, "s2"
+  r.zadd "foo", 3, "s3"
+  r.zadd "bar", 20, "s2"
+  r.zadd "bar", 30, "s3"
+  r.zadd "bar", 40, "s4"
+
+  assert 2 == r.zinterstore("foobar", ["foo", "bar"])
+  assert ["s2", "s3"] == r.zrange("foobar", 0, -1)
+
+  assert 2 == r.zinterstore("foobar", ["foo", "bar"], :weights => [10, 1])
+  assert ["s2", "s3"] == r.zrange("foobar", 0, -1)
+
+  assert "40" == r.zscore("foobar", "s2")
+  assert "60" == r.zscore("foobar", "s3")
+end
+
+test "ZINTERSTORE with AGGREGATE" do |r|
+  r.zadd "foo", 1, "s1"
+  r.zadd "foo", 2, "s2"
+  r.zadd "foo", 3, "s3"
+  r.zadd "bar", 20, "s2"
+  r.zadd "bar", 30, "s3"
+  r.zadd "bar", 40, "s4"
+
+  assert 2 == r.zinterstore("foobar", ["foo", "bar"])
+  assert ["s2", "s3"] == r.zrange("foobar", 0, -1)
+  assert "22" == r.zscore("foobar", "s2")
+  assert "33" == r.zscore("foobar", "s3")
+
+  assert 2 == r.zinterstore("foobar", ["foo", "bar"], :aggregate => :min)
+  assert ["s2", "s3"] == r.zrange("foobar", 0, -1)
+  assert "2" == r.zscore("foobar", "s2")
+  assert "3" == r.zscore("foobar", "s3")
+
+  assert 2 == r.zinterstore("foobar", ["foo", "bar"], :aggregate => :max)
+  assert ["s2", "s3"] == r.zrange("foobar", 0, -1)
+  assert "20" == r.zscore("foobar", "s2")
+  assert "30" == r.zscore("foobar", "s3")
+end
+