backrub 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 27968ba3418abbcab97c0b582bcfab4c70a18178
-  data.tar.gz: b38040b3676d3c4a765e7cf4ce8711a6c50e5aac
+  metadata.gz: 4d42c9e5402d9150f81a77e3d2359c563db3de03
+  data.tar.gz: dee8d063247b1a74db02a20807a814f24ced01c7
 SHA512:
-  metadata.gz: 5fe540cc437d3766e524506ed6dc60499a376b6a478e0a349ecf676c1ffa9c1e991a969ae7a32681540c6e7fd48b6dc8a8f90b85de7d9f3982f1a188d5d77ace
-  data.tar.gz: 75cc23037ab89e3bfc1d9fe9f503008a3ce510da7c5527ff6fdb92bdb68cfbd92a6109aaa6dfe9326363a027881f2aa8919502e1e99249a97b92cef518b40f0a
+  metadata.gz: 77cc4d20ba3e9b1ff5c1dfadef7c25e601d56aa95badd7390573f8708f5b868f4222cc2d81ee78e24365430a8df07817246ca40a58ee554abf813d75ed798db3
+  data.tar.gz: 2b55a4e20b6e55dad15a7898ac0d5e0075201a4e5dc673793c02de112547c812166df3e4acac6ec97153f782ac1b516d04c1ac4bbc6a500e32373f146281cd5c

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    backrub (0.0.1)
+    backrub (2.0.0)
       redis (~> 3.0)
 
 GEM

data/Rakefile

@@ -5,7 +5,7 @@ require 'rake/testtask'
 Rake::TestTask.new do |t|
   t.libs << 'test'
   t.libs << 'lib'
-  t.test_files = FileList['test/*_test.rb']
+  t.test_files = FileList['test/**/*_test.rb']
   t.verbose = true
 end
 

data/backrub.gemspec

@@ -1,7 +1,7 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'backrub'
+require 'backrub/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "backrub"

data/lib/backrub.rb

@@ -1,68 +1,26 @@
-require 'redis'
+require 'backrub/store/base'
+require 'backrub/store/redis'
+require 'backrub/version'
 
 module Backrub
-  VERSION = "1.0.0"
-
-  DEFAULT_BACKLOG_SIZE = 100
-
   extend self
 
-  attr_writer :redis, :backlog_size, :redis_config
-
-  def redis_config
-    @redis_config ||= {}
-  end
-
-  def redis
-    @redis ||= new_redis
+  attr_writer :store
+  def store
+    @store ||= Backrub::Store::Redis.new
   end
 
-  def subscribe(*channels)
-    raise ArgumentError.new "You have to pass at least one channel" if channels.count.zero?
-
-    if channels.count == 1 && channels.first.is_a?(Hash)
-      hash = channels.first
-
-      hash.each do |channel, offset|
-        if offset > 0
-          backlog = redis.lrange(channel, 0, offset - 1)
-
-          backlog.reverse_each do |message|
-            yield channel.to_s, message
-          end
-        end
-      end
-
-      channels = hash.keys
-    end
-
-    begin
-      # Open a new connection because the connection blocks, causing other threads to be unable to use it
-      local_redis = new_redis
-      local_redis.subscribe(*channels) do |on|
-        on.message do |channel, message|
-          yield channel, message
-        end
-      end
-    ensure
-      local_redis.quit
+  def subscribe(channels_with_backlog, &block)
+    channels_with_backlog.each do |channel, count|
+      store.backlog(channel.to_s, count.to_i, &block) unless count.zero?
     end
-  end
 
-  def publish(channel, message)
-    redis.multi do
-      redis.publish(channel, message)
-      redis.lpush(channel, message)
-      redis.ltrim(channel, 0, backlog_size - 1)
-    end
-  end
+    channels = channels_with_backlog.keys.map(&:to_s)
 
-  def backlog_size
-    @backlog_size || DEFAULT_BACKLOG_SIZE
+    store.subscribe(*channels, &block)
   end
 
-  private
-  def new_redis
-    Redis.new(redis_config)
+  def publish(channel, message)
+    store.publish(channel, message)
   end
 end

data/lib/backrub/store/base.rb

@@ -0,0 +1,17 @@
+module Backrub
+  module Store
+    class Base
+      def backlog(channel, count)
+        raise NotImplementedError
+      end
+
+      def publish(channel, message)
+        raise NotImplementedError
+      end
+
+      def subscribe(*channel)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/backrub/store/redis.rb

@@ -0,0 +1,46 @@
+require 'redis'
+
+module Backrub
+  module Store
+    class Redis < Base
+      attr_reader :config, :backlog_size
+
+      def initialize(config={}, backlog_size=100)
+        @config = config
+        @backlog_size = backlog_size
+      end
+
+      def redis
+        @redis ||= ::Redis.new(config)
+      end
+
+      def backlog(channel, count)
+        backlog = redis.lrange(channel, 0, count - 1)
+
+        backlog.reverse_each do |message|
+          yield channel, message
+        end
+      end
+
+      def publish(channel, message)
+        redis.multi do
+          redis.publish(channel, message)
+          redis.lpush(channel, message)
+          redis.ltrim(channel, 0, backlog_size - 1)
+        end
+      end
+
+      def subscribe(*channels)
+        # Open a new connection because the connection blocks, causing other threads to be unable to use it
+        local_redis = ::Redis.new(config)
+        local_redis.subscribe(*channels) do |on|
+          on.message do |channel, message|
+            yield channel, message
+          end
+        end
+      ensure
+        local_redis.quit
+      end
+    end
+  end
+end

data/lib/backrub/version.rb

@@ -0,0 +1,3 @@
+module Backrub
+  VERSION = "2.0.0"
+end

data/test/backrub/store/redis_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+class BackrubRedisTest < MiniTest::Unit::TestCase
+  def setup
+    @backlog = 20
+    @config = {}
+    @store = Backrub::Store::Redis.new(@config, @backlog)
+    @redis = @store.redis
+  end
+
+  def test_backlog
+    backlog = 20.times.map {|n| "a" * (n+1)}
+    channel = "test"
+    count = 5
+    @redis.expects(:lrange).with(channel, 0, count - 1).returns(backlog[0...count])
+
+    received_backlog = []
+
+    @store.backlog(channel, count) do |channel, message|
+      received_backlog << message
+    end
+
+    assert_equal backlog[0...count].reverse, received_backlog
+  end
+
+  def test_publishing
+    channel = "test"
+    message = "data"
+    @redis.expects(:publish).with(channel, message)
+    @redis.expects(:lpush).with(channel, message)
+    @redis.expects(:ltrim).with(channel, 0, @backlog - 1)
+
+    @store.publish(channel, message)
+  end
+
+  def test_subscribing
+    test_messages = [["test", "data"], ["test2", "data2"]]
+
+    mock_redis = mock()
+    mock_message_handler = mock()
+    mock_message_handler.expects(:message).multiple_yields(*test_messages)
+    mock_redis.expects(:subscribe).with("test", "test2").yields(mock_message_handler)
+    mock_redis.expects(:quit)
+    ::Redis.expects(:new).returns(mock_redis)
+
+    @store.subscribe("test", "test2") do |channel, message|
+      assert_equal test_messages.shift, [channel, message]
+    end
+  end
+end

data/test/backrub_test.rb

@@ -1,52 +1,39 @@
 require 'test_helper'
 
 class BackrubTest < MiniTest::Unit::TestCase
-  def test_publishing_messages
-    channel = "test"
-    message = "data"
-    Backrub.redis.expects(:publish).with(channel, message)
-    Backrub.redis.expects(:lpush).with(channel, message)
-    Backrub.redis.expects(:ltrim).with(channel, 0, Backrub::DEFAULT_BACKLOG_SIZE - 1)
-
-    Backrub.publish(channel, message)
-  end
-
-  def test_subscribing
-    fake_redis = mock()
-    subscribe_object = mock()
-    subscribe_object.expects(:message).yields(["test", "data"])
-    fake_redis.expects(:subscribe).with("test").yields(subscribe_object)
-    fake_redis.expects(:quit)
+  class MockStore < Backrub::Store::Base
 
-    Backrub.expects(:new_redis).returns(fake_redis)
+  end
 
-    Backrub.subscribe("test") do |channel, message|
-      assert_equal "test", channel
-      assert_equal "data", message
-    end
+  def setup
+    Backrub.store = MockStore.new
   end
 
-  def test_subscribing_with_hash_backlog
+  def test_subscribing
     channels = {
       first_channel: 0,
       second_channel: 2
     }
-    second_channel_data = ["first_bit", "second_bit"]
-    Backrub.redis.expects(:lrange).with(:second_channel, 0, 1).returns(second_channel_data.dup)
-    second_channel_data.unshift("third_bit")
-
-    fake_redis = mock()
-    subscribe_object = mock()
-    subscribe_object.expects(:message).yields(["second_channel", "third_bit"])
+    Backrub.store.expects(:backlog).with("second_channel", 2).multiple_yields(["second_channel", "first_bit"], ["second_channel", "second_bit"])
 
-    fake_redis.expects(:subscribe).with(:first_channel, :second_channel).yields(subscribe_object)
-    fake_redis.expects(:quit)
+    expected_data = [
+      ["second_channel", "first_bit"],
+      ["second_channel", "second_bit"],
+      ["first_channel", "third_bit"],
+    ]
 
-    Backrub.expects(:new_redis).returns(fake_redis)
+    Backrub.store.expects(:subscribe).with("first_channel", "second_channel").yields(["first_channel", "third_bit"])
 
+    data = []
     Backrub.subscribe(channels) do |channel, message|
-      assert_equal "second_channel", channel
-      assert_equal second_channel_data.pop, message
+      data << [channel, message]
     end
+
+    assert_equal expected_data, data
+  end
+
+  def test_publishing
+    Backrub.store.expects(:publish).with("test", "data")
+    Backrub.publish("test", "data")
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: backrub
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Bouke van der Bijl
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-04 00:00:00.000000000 Z
+date: 2014-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -95,6 +95,10 @@ files:
 - Rakefile
 - backrub.gemspec
 - lib/backrub.rb
+- lib/backrub/store/base.rb
+- lib/backrub/store/redis.rb
+- lib/backrub/version.rb
+- test/backrub/store/redis_test.rb
 - test/backrub_test.rb
 - test/test_helper.rb
 homepage: ''
@@ -122,6 +126,7 @@ signing_key:
 specification_version: 4
 summary: Redis-based pubsub system with a backlog
 test_files:
+- test/backrub/store/redis_test.rb
 - test/backrub_test.rb
 - test/test_helper.rb
 has_rdoc: