turnpike 0.2.0 → 0.3.0

data/.travis.yml

@@ -4,5 +4,3 @@ rvm:
   - 1.9.3
   - jruby
   - rbx
-  - rbx-2.0
-  - ree

data/Gemfile

@@ -1,4 +1,2 @@
-source "http://rubygems.org"
-
-# Specify your gem's dependencies in turnpike.gemspec
+source 'http://rubygems.org'
 gemspec

data/README.md

@@ -1,7 +1,38 @@
 # Turnpike
 
-[![travis](https://secure.travis-ci.org/hakanensari/turnpike.png)](http://travis-ci.org/hakanensari/turnpike)
+[![travis] [1]] [2]
 
-Turnpike is a Redis-backed messaging queue.
+Turnpike is a Redis-backed queue.
 
-[Read here](http://code.papercavalier.com/turnpike) for more detail.
+![turnpike] [3]
+
+Less fancily put: Turnike wraps a [Redis List] [4] and speaks Ruby colloquial.
+
+## Installation
+
+```sh
+gem install turnpike
+```
+
+# Usage
+
+An introspective moment of FIFO.
+
+```ruby
+queue = Turnpike['foo']
+
+queue << 1, 2, 3
+queue.pop # => 1
+
+queue.peek => [1, 2]
+```
+
+[Read the API] [5].
+
+It's really short.
+
+[1]: https://secure.travis-ci.org/hakanensari/turnpike.png
+[2]: http://travis-ci.org/hakanensari/turnpike
+[3]: http://f.cl.ly/items/33242X323P3M1t1G400H/turnpike.jpg
+[4]: http://redis.io/topics/data-types
+[5]: https://github.com/hakanensari/turnpike/blob/master/lib/turnpike/queue.rb

data/Rakefile

@@ -1,5 +1,4 @@
 require 'bundler/gem_tasks'
-
 require 'rake/testtask'
 
 task :default => :test

data/lib/turnpike/queue.rb

@@ -1,137 +1,90 @@
 module Turnpike
+  # A queue.
   class Queue
-    # The name of the queue.
+    # Returns a String name.
     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 - A queue name that responds to to_s.
+    def initialize(name = 'queue')
       @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.
+    # Removes all items from the queue.
     #
-    # 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?
+    # Returns Integer number of items that were removed.
+    def clear
+      redis.del name
     end
 
-    # Returns `true` if the queue is empty.
+    # Returns whether the queue is empty.
     def empty?
-      length == 0
+      size == 0
     end
 
-    # Returns the length of the queue.
-    def length
-      redis.llen(name)
+    # Return an Array of all queued items.
+    def peek
+      redis.lrange(name, 0, -1).map { |i| Marshal.load i }
     end
 
-    # Notifies observers that the state of specified items has changed.
-    def notify(*items)
-      redis.publish(name, items.join('|'))
-    end
-
-    # Observes items.
+    # Pops one or more items from the front of the queue.
     #
-    # Takes an optional timeout argument, wich defaults to 10 seconds.
+    # n - Integer number of items to pop.
     #
-    # Returns true if notified of a state change in all items.
-    def observe(*items)
-      Observer.new(name, *items).observe
-    end
-
-    alias size length
+    # Return a String item, an Array of items, or nil if the queue is empty.
+    def pop(n = 1)
+      items = []
+      n.times do
+        break unless item = redis.lpop(name)
+        items << Marshal.load(item)
+      end
 
-    # 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)
+      n == 1 ? items.first : items
     end
 
-    # Retrieves the last queued item.
+    # Pushes items to the end of the queue.
     #
-    # 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
+    # items - A splat Array of items.
+    #
+    # Returns the Integer size of the queue after the operation.
+    def push(*items)
+      if redis_version >= '2.4'
+        redis.rpush name, items.map { |i| Marshal.dump i }
       else
-        redis.rpop(name)
+        items.each { |i| redis.rpush name, Marhsal.dump(i) }
       end
     end
 
-    # Pushes items to the end of the queue.
-    def push(*items)
-      items.each { |item| redis.rpush(name, item) }
-    end
-
+    # Syntactic sugar.
     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
+    # Returns the Integer size of the queue.
+    def size
+      redis.llen name
     end
 
     # Pushes items to the front of the queue.
+    #
+    # items - A splat Array of items.
+    #
+    # Returns the Integer size of the queue after the operation.
     def unshift(*items)
-      items.each { |item| redis.lpush(name, item) }
+      if redis_version >= '2.4'
+        redis.lpush name, items.map { |i| Marshal.dump i }
+      else
+        items.each { |i| redis.lpush name, Marhsal.dump(i) }
+      end
     end
 
     private
 
     def redis
-      Redis.current ||= Redis.connect(Turnpike.options)
+      Redis.current ||= Redis.connect Turnpike.options
     end
+
+     def redis_version
+       @redis_version ||= redis.info['redis_version']
+     end
   end
 end

data/lib/turnpike/version.rb

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

data/lib/turnpike.rb

@@ -1,25 +1,31 @@
+# External dependency.
 require 'redis'
+
+# Internal dependency.
 require 'turnpike/queue'
-require 'turnpike/observer'
 
-# = Turnpike
-#
-# A Redis-backed messaging queue.
+# A Redis-backed queue.
 module Turnpike
   class << self
-    # Returns a cached or new queue.
-    def [](queue)
-      @queues[queue] ||= Queue.new(queue)
+    # Returns a Queue.
+    #
+    # name - A queue name that responds to to_s.
+    def [](name)
+      Queue.new name
     end
 
     # Sets Redis connection options.
-    def connect(options)
-      @options = options
+    #
+    # hsh - A Hash of options.
+    #
+    # Returns nothing.
+    def connect(hsh)
+      @options = hsh
     end
 
-    # Redis connection options.
-    attr :options
+    # Internal: Returns a Hash of Redis connection options.
+    def options
+      @options ||= {}
+    end
   end
-
-  @options, @queues = {}, {}
 end

data/test/turnpike_test.rb

@@ -1,8 +1,5 @@
-require 'rubygems'
 require 'bundler/setup'
-
 require 'test/unit'
-
 require File.expand_path('../lib/turnpike', File.dirname(__FILE__))
 
 class TestTurnpike < Test::Unit::TestCase
@@ -10,150 +7,77 @@ class TestTurnpike < Test::Unit::TestCase
     Redis.current.flushall
   end
 
-  def time_out_in(queue, seconds, &block)
-    original_timeout = queue.timeout
-    queue.timeout = seconds
-    block.call
-    queue.timeout = original_timeout
-  end
-
-  def test_bracket_method
-    assert_equal('turnpike:foo', Turnpike["foo"].name)
-    assert(Turnpike['foo'] == Turnpike["foo"])
+  def test_bracket
+    queue = Turnpike['foo']
+    assert_kind_of Turnpike::Queue, queue
+    assert_equal 'turnpike:foo', queue.name
   end
 
   def test_emptiness
     queue = Turnpike::Queue.new
-    assert(queue.empty?)
-
+    assert queue.empty?
     queue << 1
-    assert(!queue.empty?)
-
+    assert !queue.empty?
     queue.clear
-    assert(queue.empty?)
+    assert queue.empty?
   end
 
-  def test_pushing_items
+  def test_push
     queue = Turnpike::Queue.new
-    queue.push(1)
-    assert_equal(1, queue.length)
-
-    queue.push(2, 3)
-    assert_equal(3, queue.length)
-    assert_equal(['1', '2', '3'], queue.peek(0, 3))
+    queue.push 1
+    assert_equal 1, queue.size
+    queue.push 2, 3
+    assert_equal 3, queue.size
+    assert_equal [1, 2, 3], queue.peek
   end
 
-  def test_unshifting_items
+  def test_unshift
     queue = Turnpike::Queue.new
-    queue.unshift(1)
-    assert_equal(1, queue.length)
-
-    queue.unshift(2, 3)
-    assert_equal(3, queue.length)
-    assert_equal(['3', '2', '1'], queue.peek(0, 3))
+    queue.unshift 1
+    assert_equal 1, queue.size
+    queue.unshift 2, 3
+    assert_equal 3, queue.size
+    assert_equal [3, 2, 1], queue.peek
   end
 
-  def test_popping_items
+  def test_pop
     queue = Turnpike::Queue.new
-    queue.push(1, 2)
-    assert_equal('2', queue.pop)
-    assert_equal('1', queue.pop)
-    assert_equal(nil, queue.pop)
+    queue.push 1, 2
+    assert_equal 1, queue.pop
+    assert_equal 2, queue.pop
+    assert_equal nil, queue.pop
   end
 
-  def test_shifting_items
+  def test_pop_many
     queue = Turnpike::Queue.new
-    queue.push(1, 2)
-    assert_equal('1', queue.shift)
-    assert_equal('2', queue.shift)
-    assert_equal(nil, queue.shift)
+    queue.push 1, 2, 3
+    assert_equal [1, 2], queue.pop(2)
+    assert_equal [3], queue.pop(2)
+    assert_equal [], queue.pop(2)
   end
 
-  def test_enumeration
+  def test_order
     queue = Turnpike::Queue.new
-    queue.push(1, 2)
-    items = []
-    queue.each { |item| items << item }
-    assert_equal(['1', '2'], items)
-
-    queue.push(1, 2, 3, 4)
-    slices = []
-    queue.each_slice(3) { |slice| slices << slice }
-    assert_equal([['1', '2', '3'], ['4']], slices)
-
-    queue.push(1, 2)
-    slices = []
-    queue.each_slice(2) { |slice| slices << slice }
-    assert_equal([['1', '2']], slices)
-  end
-
-  def test_aliases
-    queue = Turnpike::Queue.new
-    queue << 1
-    assert_equal(1, queue.size)
+    queue.push 1, 2
+    queue.unshift 3
+    assert_equal 3, queue.pop
+    assert_equal 1, queue.pop
+    assert_equal 2, queue.pop
   end
 
   def test_multiple_queues
-    queue1 = Turnpike::Queue.new("foo")
-    queue2 = Turnpike::Queue.new("bar")
-
-    queue1.push(1)
-    queue2.push(2, 3)
-
-    assert_equal(1, queue1.length)
-    assert_equal(2, queue2.length)
-  end
-
-  def test_blocking_pop
-    queue = Turnpike::Queue.new
-    started_at = Time.now.to_i
-    Thread.new do
-      sleep(1)
-      queue.push(1)
-    end
-    assert_equal(0, queue.length)
-    assert_equal('1', queue.pop(true))
-    assert(Time.now.to_i - started_at > 0)
-  end
-
-  def test_blocking_shift
-    queue = Turnpike::Queue.new
-    started_at = Time.now.to_i
-    Thread.new do
-      sleep(1)
-      queue.push(1)
-    end
-    assert_equal(0, queue.length)
-    assert_equal('1', queue.shift(true))
-    assert(Time.now.to_i - started_at > 0)
+    queue1 = Turnpike::Queue.new 'foo'
+    queue2 = Turnpike::Queue.new 'bar'
+    queue1.push 1
+    queue2.push 2, 3
+    assert_equal 1, queue1.size
+    assert_equal 2, queue2.size
   end
 
-  def test_timeout
+  def test_peek
     queue = Turnpike::Queue.new
-    time_out_in queue, 1 do
-      thread = Thread.new do
-        sleep(2)
-        queue.push(1)
-      end
-      assert_equal(0, queue.length)
-      assert_equal(nil, queue.shift(true))
-
-      thread.join
-      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)
+    assert_equal [], queue.peek
+    queue << 1
+    assert_equal [1], queue.peek
   end
 end

data/turnpike.gemspec

@@ -1,31 +1,21 @@
 # -*- encoding: utf-8 -*-
-require "./lib/turnpike/version"
+$:.push File.expand_path('../lib', __FILE__)
+require 'turnpike/version'
 
 Gem::Specification.new do |s|
-  s.name        = "turnpike"
+  s.name        = 'turnpike'
   s.version     = Turnpike::VERSION
-  s.authors     = ["Paper Cavalier"]
-  s.email       = ["code@papercavalier.com"]
-  s.homepage    = "http://code.papercavalier.com/turnpike"
-  s.summary     = %q{A Redis-backed messaging queue}
-  s.description = %q{Turnpike is a Redis-backed messaging queue.}
-
-  s.rubyforge_project = "turnpike"
+  s.authors     = ['Hakan Ensari']
+  s.email       = ['hakan.ensari@papercavalier.com']
+  s.homepage    = 'http://github.com/hakanensari/turnpike'
+  s.summary     = %q{A Redis-backed queue}
+  s.description = %q{Turnpike is a Redis-backed queue.}
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-
-  {
-    'redis'               => '~> 2.2'
-  }.each do |lib, version|
-    s.add_runtime_dependency lib, version
-  end
+  s.require_paths = ['lib']
 
-  {
-    'rake'                => '~> 0.9'
-  }.each do |lib, version|
-    s.add_development_dependency lib, version
-  end
+  s.add_runtime_dependency 'redis', '~> 3.0.0.rc1'
+  s.add_development_dependency 'rake', '~> 0.9'
 end

metadata

@@ -1,30 +1,30 @@
 --- !ruby/object:Gem::Specification
 name: turnpike
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
-- Paper Cavalier
+- Hakan Ensari
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-14 00:00:00.000000000Z
+date: 2012-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
-  requirement: &70335673360420 !ruby/object:Gem::Requirement
+  requirement: &70125674238280 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: 3.0.0.rc1
   type: :runtime
   prerelease: false
-  version_requirements: *70335673360420
+  version_requirements: *70125674238280
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70335673359520 !ruby/object:Gem::Requirement
+  requirement: &70125674237780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,27 +32,25 @@ dependencies:
         version: '0.9'
   type: :development
   prerelease: false
-  version_requirements: *70335673359520
-description: Turnpike is a Redis-backed messaging queue.
+  version_requirements: *70125674237780
+description: Turnpike is a Redis-backed queue.
 email:
-- code@papercavalier.com
+- hakan.ensari@papercavalier.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
 - .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
-homepage: http://code.papercavalier.com/turnpike
+homepage: http://github.com/hakanensari/turnpike
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -64,23 +62,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 318226748875005980
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 318226748875005980
 requirements: []
-rubyforge_project: turnpike
-rubygems_version: 1.8.6
+rubyforge_project: 
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
-summary: A Redis-backed messaging queue
+summary: A Redis-backed queue
 test_files:
 - test/turnpike_test.rb

data/CHANGELOG.md

@@ -1,9 +0,0 @@
-# CHANGELOG
-
-## 0.2.0/2011-08-14
-
-* implement observer
-
-## 0.1.0/2011-07-18
-
-* first release

data/lib/turnpike/observer.rb

@@ -1,43 +0,0 @@
-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