turnpike 0.1.3 → 0.2.0

data/.travis.yml

@@ -1,4 +1,8 @@
 rvm:
   - 1.8.7
   - 1.9.2
+  - 1.9.3
+  - jruby
   - rbx
+  - rbx-2.0
+  - ree

data/CHANGELOG.md

@@ -1,3 +1,9 @@
 # CHANGELOG
 
-See [here](http://code.papercavalier.com/turnpike).
+## 0.2.0/2011-08-14
+
+* implement observer
+
+## 0.1.0/2011-07-18
+
+* first release

data/README.md

@@ -1,7 +1,7 @@
 # Turnpike
 
-[![travis](https://secure.travis-ci.org/papercavalier/turnpike.png)](http://travis-ci.org/papercavalier/turnpike)
+[![travis](https://secure.travis-ci.org/hakanensari/turnpike.png)](http://travis-ci.org/hakanensari/turnpike)
 
-Turnpike is a Redis-backed message processing queue.
+Turnpike is a Redis-backed messaging queue.
 
 [Read here](http://code.papercavalier.com/turnpike) for more detail.

data/lib/turnpike/observer.rb

@@ -0,0 +1,43 @@
+module Turnpike
+  class Observer
+    def initialize(name, *items)
+      @timeout      = items.last.is_a?(Hash) ? items.pop[:timeout] : 10
+      @name, @items = name, items
+    end
+
+    def observe
+      if reactor_running?
+        timer = EM.add_timer(@timeout) { unsubscribe }
+        subscribe && EM.cancel_timer(timer)
+      else
+        thr = Thread.new { subscribe }
+        !!thr.join(@timeout)
+      end
+    end
+
+    private
+
+    def reactor_running?
+      defined?(EM) && EM.reactor_running?
+    end
+
+    def subscribe
+      redis.subscribe(@name) do |on|
+        on.message do |channel, message|
+          message.split('|').each { |item| @items.delete(item) }
+          unsubscribe if @items.empty?
+        end
+      end
+
+      @items.empty?
+    end
+
+    def redis
+      @redis ||= Redis.connect(Turnpike.options)
+    end
+
+    def unsubscribe
+      redis.unsubscribe
+    end
+  end
+end

data/lib/turnpike/queue.rb

@@ -0,0 +1,137 @@
+module Turnpike
+  class Queue
+    # The name of the queue.
+    attr :name
+
+    # Specifies for how many seconds a blocking pop or shift should
+    # block the connection.
+    attr_accessor :timeout
+
+    # Default timeout to 0.
+    @timeout = 0
+
+    # Creates a new queue.
+    #
+    # Takes an optional name.
+    def initialize(name = 'default')
+      @name = "turnpike:#{name}"
+    end
+
+    # Removes all queued items.
+    def clear
+      redis.del(name)
+    end
+
+    # Calls block once for each queued item.
+    #
+    # Takes an optional boolean argument to specify if the command
+    # should block the connection when the queue is empty. This
+    # argument defaults to false.
+    def each(blocking = false, &block)
+      while item = shift(blocking)
+        block.call(item)
+      end
+    end
+
+    # Iterates the given block for each slice of _n_ queued items.
+    #
+    # Takes an optional boolean argument to specify if the command
+    # should block the connection when the queue is empty. This
+    # argument defaults to false.
+    def each_slice(n, blocking = false, &block)
+      slice = []
+
+      each(blocking) do |item|
+        slice << item
+        if slice.size == n
+          block.call(slice)
+          slice = []
+        end
+      end
+
+      yield slice unless slice.empty?
+    end
+
+    # Returns `true` if the queue is empty.
+    def empty?
+      length == 0
+    end
+
+    # Returns the length of the queue.
+    def length
+      redis.llen(name)
+    end
+
+    # Notifies observers that the state of specified items has changed.
+    def notify(*items)
+      redis.publish(name, items.join('|'))
+    end
+
+    # Observes items.
+    #
+    # Takes an optional timeout argument, wich defaults to 10 seconds.
+    #
+    # Returns true if notified of a state change in all items.
+    def observe(*items)
+      Observer.new(name, *items).observe
+    end
+
+    alias size length
+
+    # Returns an array of items currently queued.
+    #
+    # `start` is an integer and indicates the start offset, 0 being the
+    # first queued item. If negative, it indicates the offset from the
+    # end, -1 being the last queued item.
+    #
+    # `count` is also an integer and indicates the number of items to
+    # return.
+    def peek(start, count)
+      redis.lrange(name, start, count)
+    end
+
+    # Retrieves the last queued item.
+    #
+    # Takes an optional boolean argument to specify if the command
+    # should block the connection when the queue is empty. This
+    # argument defaults to false.
+    def pop(blocking = false)
+      if blocking
+        redis.brpop(name, timeout)[1] rescue nil
+      else
+        redis.rpop(name)
+      end
+    end
+
+    # Pushes items to the end of the queue.
+    def push(*items)
+      items.each { |item| redis.rpush(name, item) }
+    end
+
+    alias << push
+
+    # Retrieves the first queued item.
+    #
+    # Takes an optional boolean argument to specify if the command
+    # should block the connection when the queue is empty. This
+    # argument defaults to false.
+    def shift(blocking = false)
+      if blocking
+        redis.blpop(name, timeout)[1] rescue nil
+      else
+        redis.lpop(name)
+      end
+    end
+
+    # Pushes items to the front of the queue.
+    def unshift(*items)
+      items.each { |item| redis.lpush(name, item) }
+    end
+
+    private
+
+    def redis
+      Redis.current ||= Redis.connect(Turnpike.options)
+    end
+  end
+end

data/lib/turnpike/version.rb

@@ -1,3 +1,3 @@
-class Turnpike
-  VERSION = '0.1.3'
+module Turnpike
+  VERSION = '0.2.0'
 end

data/lib/turnpike.rb

@@ -1,140 +1,25 @@
 require 'redis'
+require 'turnpike/queue'
+require 'turnpike/observer'
 
-# A Redis-backed queue.
-class Turnpike
+# = Turnpike
+#
+# A Redis-backed messaging queue.
+module Turnpike
   class << self
-    def options
-      @options ||= {}
+    # Returns a cached or new queue.
+    def [](queue)
+      @queues[queue] ||= Queue.new(queue)
     end
 
-    # Timeout, in seconds, for blocking `pop` or `shift`.
-    attr_accessor :timeout
-
-    @timeout = 0
-
+    # Sets Redis connection options.
     def connect(options)
       @options = options
     end
 
-    # Returns a queue. Syntactic sugar.
-    def [](queue)
-      queues[queue] ||= new(queue)
-    end
-
-    def configure(&block)
-      yield self
-    end
-
-    private
-
-    def queues
-      @queues ||= Hash.new
-    end
+    # Redis connection options.
+    attr :options
   end
 
-  # The name of the queue.
-  attr :name
-
-  # Creates a new queue.
-  #
-  # Takes an optional name.
-  def initialize(name = 'default')
-    @name = "turnpike:#{name}"
-  end
-
-  # Removes all queued items.
-  def clear
-    redis.del(name)
-  end
-
-  # Calls block once for each queued item.
-  #
-  # Takes an optional boolean argument to specify if the command should block
-  # the connection when the queue is empty. This argument defaults to false.
-  def each(blocking = false, &block)
-    while item = shift(blocking)
-      block.call(item)
-    end
-  end
-
-  # Iterates the given block for each slice of `n` queued items.
-  #
-  # Takes an optional boolean argument to specify if the command should block
-  # the connection when the queue is empty. This argument defaults to false.
-  def each_slice(n, blocking = false, &block)
-    slice = []
-
-    each(blocking) do |item|
-      slice << item
-      if slice.size == n
-        yield slice
-        slice = []
-      end
-    end
-
-    yield slice unless slice.empty?
-  end
-
-  # Returns `true` if the queue is empty.
-  def empty?
-    length == 0
-  end
-
-  # Returns the length of the queue.
-  def length
-    redis.llen(name)
-  end
-  alias size length
-
-  # Returns an array of items currently queued.
-  #
-  # `start` is an integer and indicates the start offset, 0 being the first
-  # queued item. If negative, it indicates the offset from the end, -1 being
-  # the last queued item.
-  #
-  # `count` is also an integer and indicates the number of items to return.
-  def peek(start, count)
-    redis.lrange(name, start, count)
-  end
-
-  # Retrieves the last queued item.
-  #
-  # Takes an optional boolean argument to specify if the command should block
-  # the connection when the queue is empty. This argument defaults to false.
-  def pop(blocking = false)
-    if blocking
-      redis.brpop(name, Turnpike.timeout)[1] rescue nil
-    else
-      redis.rpop(name)
-    end
-  end
-
-  # Pushes items to the end of the queue.
-  def push(*items)
-    items.each { |item| redis.rpush(name, item) }
-  end
-  alias << push
-
-  # Retrieves the first queued item.
-  #
-  # Takes an optional boolean argument to specify if the command should block
-  # the connection when the queue is empty. This argument defaults to false.
-  def shift(blocking = false)
-    if blocking
-      redis.blpop(name, Turnpike.timeout)[1] rescue nil
-    else
-      redis.lpop(name)
-    end
-  end
-
-  # Pushes items to the front of the queue.
-  def unshift(*items)
-    items.each { |item| redis.lpush(name, item) }
-  end
-
-  private
-
-  def redis
-    Redis.current ||= Redis.connect(Turnpike.options)
-  end
+  @options, @queues = {}, {}
 end

data/test/turnpike_test.rb

@@ -10,20 +10,20 @@ class TestTurnpike < Test::Unit::TestCase
     Redis.current.flushall
   end
 
-  def time_out_in(seconds, &block)
-    original_timeout = Turnpike.timeout
-    Turnpike.configure { |c| c.timeout = seconds }
+  def time_out_in(queue, seconds, &block)
+    original_timeout = queue.timeout
+    queue.timeout = seconds
     block.call
-    Turnpike.configure { |c| c.timeout = original_timeout }
+    queue.timeout = original_timeout
   end
 
   def test_bracket_method
-   assert_equal("turnpike:foo", Turnpike["foo"].name)
-   assert(Turnpike["foo"] == Turnpike["foo"])
+    assert_equal('turnpike:foo', Turnpike["foo"].name)
+    assert(Turnpike['foo'] == Turnpike["foo"])
   end
 
   def test_emptiness
-    queue = Turnpike.new
+    queue = Turnpike::Queue.new
     assert(queue.empty?)
 
     queue << 1
@@ -34,7 +34,7 @@ class TestTurnpike < Test::Unit::TestCase
   end
 
   def test_pushing_items
-    queue = Turnpike.new
+    queue = Turnpike::Queue.new
     queue.push(1)
     assert_equal(1, queue.length)
 
@@ -44,7 +44,7 @@ class TestTurnpike < Test::Unit::TestCase
   end
 
   def test_unshifting_items
-    queue = Turnpike.new
+    queue = Turnpike::Queue.new
     queue.unshift(1)
     assert_equal(1, queue.length)
 
@@ -54,7 +54,7 @@ class TestTurnpike < Test::Unit::TestCase
   end
 
   def test_popping_items
-    queue = Turnpike.new
+    queue = Turnpike::Queue.new
     queue.push(1, 2)
     assert_equal('2', queue.pop)
     assert_equal('1', queue.pop)
@@ -62,7 +62,7 @@ class TestTurnpike < Test::Unit::TestCase
   end
 
   def test_shifting_items
-    queue = Turnpike.new
+    queue = Turnpike::Queue.new
     queue.push(1, 2)
     assert_equal('1', queue.shift)
     assert_equal('2', queue.shift)
@@ -70,7 +70,7 @@ class TestTurnpike < Test::Unit::TestCase
   end
 
   def test_enumeration
-    queue = Turnpike.new
+    queue = Turnpike::Queue.new
     queue.push(1, 2)
     items = []
     queue.each { |item| items << item }
@@ -88,14 +88,14 @@ class TestTurnpike < Test::Unit::TestCase
   end
 
   def test_aliases
-    queue = Turnpike.new
+    queue = Turnpike::Queue.new
     queue << 1
     assert_equal(1, queue.size)
   end
 
   def test_multiple_queues
-    queue1 = Turnpike.new("foo")
-    queue2 = Turnpike.new("bar")
+    queue1 = Turnpike::Queue.new("foo")
+    queue2 = Turnpike::Queue.new("bar")
 
     queue1.push(1)
     queue2.push(2, 3)
@@ -105,7 +105,7 @@ class TestTurnpike < Test::Unit::TestCase
   end
 
   def test_blocking_pop
-    queue = Turnpike.new
+    queue = Turnpike::Queue.new
     started_at = Time.now.to_i
     Thread.new do
       sleep(1)
@@ -117,7 +117,7 @@ class TestTurnpike < Test::Unit::TestCase
   end
 
   def test_blocking_shift
-    queue = Turnpike.new
+    queue = Turnpike::Queue.new
     started_at = Time.now.to_i
     Thread.new do
       sleep(1)
@@ -129,8 +129,8 @@ class TestTurnpike < Test::Unit::TestCase
   end
 
   def test_timeout
-    time_out_in 1 do
-      queue = Turnpike.new
+    queue = Turnpike::Queue.new
+    time_out_in queue, 1 do
       thread = Thread.new do
         sleep(2)
         queue.push(1)
@@ -142,4 +142,18 @@ class TestTurnpike < Test::Unit::TestCase
       assert_equal(1, queue.length)
     end
   end
+
+  def test_observer
+    items = ['foo', 'bar']
+    queue = Turnpike::Queue.new
+    Thread.new do
+      sleep 1
+      queue.notify(*items)
+    end
+
+    assert queue.observe(*items)
+
+    items << { :timeout => 1 }
+    assert !queue.observe(*items)
+  end
 end

data/turnpike.gemspec

@@ -7,8 +7,8 @@ Gem::Specification.new do |s|
   s.authors     = ["Paper Cavalier"]
   s.email       = ["code@papercavalier.com"]
   s.homepage    = "http://code.papercavalier.com/turnpike"
-  s.summary     = %q{Turnpike is a Redis-backed message processing queue.}
-  s.description = %q{Turnpike is a Redis-backed message processing queue.}
+  s.summary     = %q{A Redis-backed messaging queue}
+  s.description = %q{Turnpike is a Redis-backed messaging queue.}
 
   s.rubyforge_project = "turnpike"
 

metadata

@@ -1,104 +1,86 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: turnpike
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 1
-  - 3
-  version: 0.1.3
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Paper Cavalier
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-07-22 00:00:00 +01:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-08-14 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: redis
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &70335673360420 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 2
-        - 2
-        version: "2.2"
+      - !ruby/object:Gem::Version
+        version: '2.2'
   type: :runtime
   prerelease: false
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
+  version_requirements: *70335673360420
+- !ruby/object:Gem::Dependency
   name: rake
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  requirement: &70335673359520 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 9
-        version: "0.9"
+      - !ruby/object:Gem::Version
+        version: '0.9'
   type: :development
   prerelease: false
-  version_requirements: *id002
-description: Turnpike is a Redis-backed message processing queue.
-email: 
+  version_requirements: *70335673359520
+description: Turnpike is a Redis-backed messaging queue.
+email:
 - code@papercavalier.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
-- .rvmrc
 - .travis.yml
 - CHANGELOG.md
 - Gemfile
 - README.md
 - Rakefile
 - lib/turnpike.rb
+- lib/turnpike/observer.rb
+- lib/turnpike/queue.rb
 - lib/turnpike/version.rb
 - test/turnpike_test.rb
 - turnpike.gemspec
-has_rdoc: true
 homepage: http://code.papercavalier.com/turnpike
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3844900520271104281
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+      hash: 318226748875005980
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3844900520271104281
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
+      hash: 318226748875005980
 requirements: []
-
 rubyforge_project: turnpike
-rubygems_version: 1.3.7
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
-summary: Turnpike is a Redis-backed message processing queue.
-test_files: 
+summary: A Redis-backed messaging queue
+test_files:
 - test/turnpike_test.rb

data/.rvmrc

@@ -1 +0,0 @@
-rvm --create use 1.9.2@turnpike