pigeon 0.9.3 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fa0f5ce613ef0b66cded863d01259e09099eeb27
+  data.tar.gz: 6b1d997dda5b4664c6cf77524a840aee230ac54d
+SHA512:
+  metadata.gz: 18a1edfd20eaec356b8297665db24eb96d18e2e90fb8c7699a71e081c599f3d809476e64d7e05dae8fedd3a7973a924c6500013c90bacb0483dcfdddd7ee2de4
+  data.tar.gz: 3c9bc25b916a9b5ca262ed489c117032185b5fc3e8ffc9feab37f94dd8b7d7f4df5a394063d48dfe0945834ef7a9fedd0d604d50f75162f8fa6e25833dc3771d

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+before_install:
+- gem install bundler
+rvm:
+- 1.9.3-p551
+- 2.0.0-p598
+- 2.1.5
+- 2.2.0

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org/'
+
+gem 'eventmachine'
+
+group :development do
+  gem 'minitest-reporters', path: '~/git/minitest-reporters'
+  gem 'minitest'
+  gem 'jeweler'
+end

data/README.md

@@ -79,4 +79,4 @@ This engine is currently in development.
 
 ## Copyright
 
-Copyright (c) 2009-2013 Scott Tadman, The Working Group
+Copyright (c) 2009-2015 Scott Tadman, The Working Group

data/Rakefile

@@ -3,6 +3,7 @@ require 'rake'
 
 begin
   require 'jeweler'
+
   Jeweler::Tasks.new do |gem|
     gem.name = "pigeon"
     gem.summary = %Q{Simple daemonized EventMachine engine framework with plug-in support}
@@ -10,21 +11,20 @@ begin
     gem.email = "github@tadman.ca"
     gem.homepage = "http://github.com/twg/pigeon"
     gem.authors = %w[ tadman ]
-    gem.add_development_dependency 'eventmachine'
     gem.executables  = [ ]
   end
+
   Jeweler::GemcutterTasks.new
 rescue LoadError
   puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
 end
 
 require 'rake/testtask'
+
 Rake::TestTask.new(:test) do |test|
   test.libs << 'lib' << 'test'
   test.pattern = 'test/**/*_test.rb'
   test.verbose = true
 end
 
-task :test => :check_dependencies
-
-task :default => :test
+task default: :test

data/VERSION

@@ -1 +1 @@
-0.9.3
+1.0.0

data/lib/pigeon.rb

@@ -13,6 +13,14 @@ module Pigeon
   autoload(:SortedArray, 'pigeon/sorted_array')
   autoload(:Support, 'pigeon/support')
   autoload(:Task, 'pigeon/task')
+
+  # == Module Methods =======================================================
+
+  def self.version
+    @version ||= File.readlines(
+      File.expand_path('../VERSION'), File.dirname(__FILE__)
+    )[0].chomp
+  end
 end
 
 # NOTE: This file needs to be directly loaded due to some kind of peculiar

data/lib/pigeon/dispatcher.rb

@@ -10,7 +10,7 @@ class Pigeon::Dispatcher
   # == Properties ===========================================================
   
   option_accessor :thread_limit,
-    :default => 24
+    default: 24
 
   attr_reader :exceptions
 

data/lib/pigeon/engine.rb

@@ -21,29 +21,29 @@ class Pigeon::Engine
   option_accessor :name
   option_accessor :pid_file_name
   option_accessor :foreground,
-    :boolean => true
+    boolean: true
   option_accessor :debug,
-    :boolean => true
+    boolean: true
   option_accessor :log_rotation
   option_accessor :engine_log_name,
-    :default => 'engine.log'
+    default: 'engine.log'
   option_accessor :engine_logger
   option_accessor :query_log_name,
-    :default => 'query.log'
+    default: 'query.log'
   option_accessor :query_logger
   option_accessor :try_pid_dirs,
-    :default => %w[
+    default: %w[
       /var/run
       /tmp
     ].freeze
   option_accessor :try_log_dirs,
-    :default => %w[
+    default: %w[
       /var/log
       /tmp
     ].freeze
   option_accessor :threaded,
-    :boolean => true,
-    :default => false
+    boolean: true,
+    default: false
     
   attr_reader :id
   attr_reader :state
@@ -125,14 +125,14 @@ class Pigeon::Engine
     EventMachine.run do
       engine = new(options)
       
-      yield(engine) if (block_given?)
-    
       Signal.trap('INT') do
         engine.terminate
       end
 
       Pigeon::Engine.register_engine(engine)
 
+      yield(engine) if (block_given?)
+
       engine.run
     end
 
@@ -148,7 +148,7 @@ class Pigeon::Engine
     
     pid = Pigeon::Support.daemonize(logger) do
       launch({
-        :logger => logger
+        logger: logger
       }.merge(options || { }))
     end
 
@@ -162,7 +162,7 @@ class Pigeon::Engine
   def self.run
     yield($$) if (block_given?)
 
-    launch(:foreground => true)
+    launch(foreground: true)
   end
   
   def self.stop
@@ -171,6 +171,7 @@ class Pigeon::Engine
     if (pid)
       begin
         Process.kill('INT', pid)
+        
       rescue Errno::ESRCH
         # No such process exception
         pid = nil
@@ -178,7 +179,7 @@ class Pigeon::Engine
       
       begin
         while (Process.kill(0, pid))
-          sleep(1)
+          Pigeon::Support.nap(0.1)
         end
       rescue Errno::ESRCH
         # No such process, already terminated
@@ -195,8 +196,11 @@ class Pigeon::Engine
   end
 
   def self.restart
-    self.stop
-    self.start
+    self.stop do |old_pid|
+      self.start do |pid|
+        yield(pid, old_pid) if (block_given?)
+      end
+    end
   end
   
   def self.running?
@@ -248,6 +252,10 @@ class Pigeon::Engine
   def self.unregister_engine(engine)
     @engines.delete(engine)
   end
+
+  def self.clear_engines!
+    @engines = [ ]
+  end
   
   # Schedules a block for execution on the main EventMachine thread. This is
   # a wrapper around the EventMachine.schedule method.
@@ -359,7 +367,10 @@ class Pigeon::Engine
   # events.
   def terminate
     wrap_chain(:stop) do
-      EventMachine.stop_event_loop
+      if (EventMachine.reactor_running?)
+        EventMachine.stop_event_loop
+      end
+
       @state = :terminated
     end
   end

data/lib/pigeon/launcher.rb

@@ -18,24 +18,53 @@ class Pigeon::Launcher
   end
   
   def handle_args(*args)
-    op = OptionParser.new
+    op = OptionParser.new do |parser|
+      parser.on('-v', '--version') do
+        pigeon_version = 'Pigeon %s' % Pigeon.version
+
+        version =
+          if (@engine.respond_to?(:version))
+            '%s (%s)' % [ @engine.version, pigeon_version ]
+          else
+            pigeon_version
+          end
+
+        puts version
+        exit(0)
+      end
+    end
     
     command = op.parse(*args.flatten).first
 
     begin
       case (command)
       when 'start'
-        @engine.start(&method(:start))
+        @engine.start do |pid|
+          yield(pid) if (block_given?)
+          self.start(pid)
+        end
       when 'stop'
-        @engine.stop(&method(:stop))
+        @engine.stop do |pid|
+          yield(pid) if (block_given?)
+          self.stop(pid)
+        end
       when 'restart'
-        @engine.restart(&method(:restart))
+        @engine.restart do |pid, old_pid|
+          yield(pid, old_pid) if (block_given?)
+          self.restart(pid, old_pid)
+        end
       when 'status'
-        @engine.status(&method(:status))
+        @engine.status do |pid|
+          yield(pid) if (block_given?)
+          self.status(pid)
+        end
       when 'run'
         @engine.engine_logger = Pigeon::Logger.new(STDOUT)
 
-        @engine.run(&method(:run))
+        @engine.run do |pid|
+          yield(pid) if (block_given?)
+          self.run(pid)
+        end
       else
         usage
       end

data/lib/pigeon/support.rb

@@ -30,7 +30,6 @@ module Pigeon::Support
                   if (thread.backtrace)
                     logger.error("\t" + thread.backtrace.join("\n\t"))
                   end
-                  
                 end
               end
 
@@ -39,22 +38,41 @@ module Pigeon::Support
           end
 
           begin
-            Process.wait(daemon_pid)
+            interrupted = false
+
+            Signal.trap('INT') do
+              interrupted = true
+              Process.kill('INT', daemon_pid)
+
+              relaunch = false
+            end
+
+            pid, status = Process.wait2(daemon_pid)
+
+            if (interrupted)
+              logger.info("Supervisor #{Process.pid} received termination signal, shut down child #{daemon_pid}")
+            end
 
             # A non-zero exit status indicates some sort of error, so the
             # process will be relaunched after a short delay.
             relaunch = ($? != 0)
 
-          rescue Interrupt
-            Process.kill('INT', daemon_pid)
-
-            relaunch = false
+          ensure
+            # Reset Signal handler before forking again
+            Signal.trap('INT') do
+            end
           end
           
           if (relaunch)
-            logger.info("Will relaunch in %d seconds" % delay)
+            begin
+              logger.info("Supervisor #{Process.pid} will relaunch in %d seconds" % delay)
+              sleep(delay)
+
+            rescue Interrupt
+              logger.info("Supervisor #{Process.pid} abandoing restart because of termination")
 
-            sleep(delay)
+              relaunch = false
+            end
           else
             logger.info("Terminated normally")
           end
@@ -66,13 +84,17 @@ module Pigeon::Support
       wfd.close
     end
 
-    Process.wait(forked_pid)
+    pid, status = Process.wait2(forked_pid)
 
     daemon_pid = rfd.readline
     rfd.close
     
     daemon_pid.to_i
   end
+
+  def nap(time)
+    select(nil, nil, nil, time.to_f)
+  end
   
   # Finds the first directory in the given list that exists and is
   # writable. Returns nil if none match.

data/lib/pigeon/task.rb

@@ -1,4 +1,9 @@
 class Pigeon::Task
+  # == Exceptions ===========================================================
+
+  class EngineRequired < StandardError
+  end
+
   # == Constants ============================================================
   
   # == Properties ===========================================================
@@ -35,6 +40,10 @@ class Pigeon::Task
     @context = context
     @engine = engine || Pigeon::Engine.default_engine
     @created_at = Time.now
+
+    unless (@engine)
+      raise EngineRequired, "Task creation requires an active Pigeon::Engine"
+    end
     
     after_initialized
   end

data/pigeon.gemspec

@@ -2,14 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
+# stub: pigeon 1.0.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "pigeon"
-  s.version = "0.9.3"
+  s.version = "1.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
   s.authors = ["tadman"]
-  s.date = "2013-04-26"
+  s.date = "2015-02-18"
   s.description = "Pigeon is a simple way to get started building an EventMachine engine that's intended to run as a background job."
   s.email = "github@tadman.ca"
   s.extra_rdoc_files = [
@@ -18,6 +20,8 @@ Gem::Specification.new do |s|
   ]
   s.files = [
     ".document",
+    ".travis.yml",
+    "Gemfile",
     "LICENSE",
     "README.md",
     "Rakefile",
@@ -51,20 +55,28 @@ Gem::Specification.new do |s|
     "test/unit/pigeon_test.rb"
   ]
   s.homepage = "http://github.com/twg/pigeon"
-  s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.25"
+  s.rubygems_version = "2.2.2"
   s.summary = "Simple daemonized EventMachine engine framework with plug-in support"
 
   if s.respond_to? :specification_version then
-    s.specification_version = 3
+    s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<eventmachine>, [">= 0"])
+      s.add_runtime_dependency(%q<eventmachine>, [">= 0"])
+      s.add_development_dependency(%q<minitest-reporters>, [">= 0"])
+      s.add_development_dependency(%q<minitest>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
     else
       s.add_dependency(%q<eventmachine>, [">= 0"])
+      s.add_dependency(%q<minitest-reporters>, [">= 0"])
+      s.add_dependency(%q<minitest>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
     end
   else
     s.add_dependency(%q<eventmachine>, [">= 0"])
+    s.add_dependency(%q<minitest-reporters>, [">= 0"])
+    s.add_dependency(%q<minitest>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
   end
 end
 

data/test/helper.rb

@@ -1,35 +1,63 @@
 require 'rubygems'
-require 'test/unit'
+require 'bundler/setup'
 
-$LOAD_PATH.unshift(File.expand_path(*%w[ .. lib ]), File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'minitest'
 
-require 'timeout'
+module Minitest
+  # The default Minitest behavior to intercept at_exit and rewrite the exit
+  # status code based on test results is okay for the parent process, but
+  # causes friction when using fork within tests. Here it's disabled unless
+  # the process terminating is the parent.
+  def self.autorun
+    return if (@at_exit_hook_installed)
 
-require 'rubygems'
+    @at_exit_hook_installed = Process.pid
+
+    at_exit do
+      next if $! and not ($!.kind_of? SystemExit and $!.success?)
+
+      exit_code = Minitest.run(ARGV)
+
+      @@after_run.reverse_each do |block|
+        block.call
+
+        if (Process.pid != @at_exit_hook_installed)
+          break
+        end
+      end
 
-begin
-  gem 'eventmachine'
-rescue => e
-  raise "EventMachine gem is not installed or could not be loaded: [#{e.class}] #{e}"
+      exit(exit_code)
+    end
+  end
 end
 
+require 'minitest/reporters'
+require 'minitest/autorun'
+require 'timeout'
+
+Minitest::Reporters.use!(Minitest::Reporters::SpecReporter.new)
+
+$LOAD_PATH.unshift(File.expand_path(File.join(*%w[ .. lib ]), File.dirname(__FILE__)))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
 require 'pigeon'
+require 'eventmachine'
 
-class Test::Unit::TestCase
+class Minitest::Test
   def assert_timeout(time, message = nil, &block)
     Timeout::timeout(time, &block)
+
   rescue Timeout::Error
     flunk(message || 'assert_timeout timed out')
   end
   
   def assert_eventually(time = nil, message = nil, &block)
-    start_time = Time.now.to_i
+    start_time = Time.now.to_f
 
     while (!block.call)
       select(nil, nil, nil, 0.1)
       
-      if (time and (Time.now.to_i - start_time > time))
+      if (time and (Time.now.to_f - start_time > time))
         flunk(message || 'assert_eventually timed out')
       end
     end
@@ -37,32 +65,64 @@ class Test::Unit::TestCase
 
   def engine
     exception = nil
+    test_thread = nil
     
-    Pigeon::Engine.launch do |new_engine|
-      @engine = new_engine
+    engine_thread =
+      Thread.new do
+        Thread.abort_on_exception = true
+
+        Pigeon::Engine.clear_engines!
+
+        # Create a thread for the engine to run on
+        begin
+          Pigeon::Engine.launch do |launched|
+            @engine = launched
+          end
+
+        rescue Object => exception
+        end
+      end
 
-      # Execute the test code in a separate thread to avoid blocking
-      # the EventMachine loop.
+    test_thread =
       Thread.new do
+        # Execute the test code in a separate thread to avoid blocking
+        # the EventMachine loop.
         begin
-          Thread.abort_on_exception = true
-          yield
+          while (!@engine or Pigeon::Engine.default_engine != @engine)
+            # Wait impatiently.
+          end
+
+          yield(@engine)
         rescue Object => exception
         ensure
           begin
-            # Regardless what happened, always terminate the engine.
-            @engine.terminate
-          rescue Object => e
+            if (EventMachine.reactor_running?)
+              EventMachine.stop_event_loop
+            end
+          rescue Object
+            STDERR.puts("[#{exception.class}] #{exception}")
             # Shutting down may trigger an exception from time to time
             # if the engine itself has failed.
-            STDERR.puts("Exception: [#{e.class}] #{e}")
           end
         end
       end
+
+    test_thread.join
+
+    begin
+      Timeout.timeout(1) do
+        engine_thread.join
+      end
+    rescue Timeout::Error
+      engine_thread.kill
     end
     
     if (exception)
       raise exception
     end
+  ensure
+    if (engine_thread)
+      engine_thread.kill
+    end
   end
 end

data/test/unit/pigeon_backlog_test.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.join(*%w[ .. helper ]), File.dirname(__FILE__))
 
-class PigeonQueueTest < Test::Unit::TestCase
+class PigeonQueueTest < Minitest::Test
   def test_empty_queue
     queue = Pigeon::Queue.new
     

data/test/unit/pigeon_dispatcher_test.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.join(*%w[ .. helper ]), File.dirname(__FILE__))
 
-class PigeonDispatcherTest < Test::Unit::TestCase
+class PigeonDispatcherTest < Minitest::Test
   def test_routine_dispatching
     dispatcher = Pigeon::Dispatcher.new
     

data/test/unit/pigeon_engine_test.rb

@@ -71,10 +71,12 @@ class ShutdownCallbackTestEngine < Pigeon::Engine
   end
 end
 
-class TestPigeonEngine < Test::Unit::TestCase
+class TestPigeonEngine < Minitest::Test
   def test_default_options
     assert TestEngine.engine_logger
     assert TestEngine.engine_logger.is_a?(Logger)
+
+    assert_equal nil, TestEngine.default_engine
   end
   
   def test_example_subclass
@@ -82,13 +84,13 @@ class TestPigeonEngine < Test::Unit::TestCase
     
     read_fd, write_fd = IO.pipe
     
-    TestEngine.start(:pipe => write_fd) do |pid|
+    TestEngine.start(pipe: write_fd) do |pid|
       assert pid
       engine_pid = pid
     end
     
     write_fd.close
-    
+
     Timeout::timeout(5) do
       assert_equal "STARTED\n", read_fd.readline
     end
@@ -96,7 +98,7 @@ class TestPigeonEngine < Test::Unit::TestCase
     TestEngine.status do |pid|
       assert_equal engine_pid, pid
     end
-    
+
     TestEngine.stop do |pid|
       assert_equal engine_pid, pid
     end
@@ -111,7 +113,7 @@ class TestPigeonEngine < Test::Unit::TestCase
     
     read_fd, write_fd = IO.pipe
     
-    engine_pid = TestEngine.start(:pipe => write_fd)
+    engine_pid = TestEngine.start(pipe: write_fd)
     
     write_fd.close
     
@@ -135,7 +137,7 @@ class TestPigeonEngine < Test::Unit::TestCase
     
     read_fd, write_fd = IO.pipe
     
-    CallbackTestEngine.start(:pipe => write_fd) do |pid|
+    CallbackTestEngine.start(pipe: write_fd) do |pid|
       assert pid
       engine_pid = pid
     end
@@ -169,6 +171,23 @@ class TestPigeonEngine < Test::Unit::TestCase
     
     assert_equal expected_callbacks, read_fd.read.split(/\n/).collect(&:to_sym)
   end
+
+  def test_fork_exitstatus
+    child_pid = fork do
+    end
+
+    pid, status = Process.wait2(child_pid)
+
+    assert_equal 0, status.exitstatus
+
+    child_pid = fork do
+      exit(90)
+    end
+
+    pid, status = Process.wait2(child_pid)
+
+    assert_equal 90, status.exitstatus
+  end
   
   def test_shutdown_engine
     engine_pid = nil
@@ -179,15 +198,12 @@ class TestPigeonEngine < Test::Unit::TestCase
     
     assert engine_pid
     
-    sleep(1)
-    
-    running_pid = nil
-    
-    ShutdownEngine.status do |pid|
-      running_pid = pid
+    assert_eventually(5) do
+      !ShutdownEngine.status
     end
-    
-    assert_equal nil, running_pid
+
+  ensure
+    ShutdownEngine.stop
   end
   
   def test_shutdown_engine_with_blocking_callback

data/test/unit/pigeon_launcher_test.rb

@@ -6,7 +6,7 @@ class Pigeon::Launcher
   end
 end
 
-class PigeonLauncherTest < Test::Unit::TestCase
+class PigeonLauncherTest < Minitest::Test
   def test_default_launcher
     pid = Pigeon::Launcher.launch
     
@@ -19,41 +19,40 @@ class PigeonLauncherTest < Test::Unit::TestCase
   end
 
   def test_triggers
-    triggered = Hash.new do |h, k|
-      h[k] = 0
-    end
+    launcher = Pigeon::Launcher.new(Pigeon::Engine)
+
+    triggered = Hash.new { |h,k| h[k] = [ ] }
     
-    Pigeon::Launcher.new(Pigeon::Engine).handle_args('start') do
-      start do
-        triggered[:start] += 1
-      end
+    launcher.handle_args('start') do |pid|
+      triggered[:start] << pid
     end
 
-    Pigeon::Launcher.new(Pigeon::Engine).handle_args('restart') do
-      restart do
-        triggered[:restart] += 1
-      end
+    launcher.handle_args('status') do |pid|
+      triggered[:status] << pid
     end
 
-    Pigeon::Launcher.new(Pigeon::Engine).handle_args('status') do
-      status do
-        triggered[:status] += 1
-      end
+    launcher.handle_args('restart') do |pid, old_pid|
+      triggered[:restart] << pid
     end
 
-    Pigeon::Launcher.new(Pigeon::Engine).handle_args('stop') do
-      stop do
-        triggered[:stop] += 1
-      end
+    launcher.handle_args('status') do |pid|
+      triggered[:status] << pid
     end
-    
-    # FIX: Test `run`
-    
-    if (false)
-      assert_equal 1, triggered[:start]
-      assert_equal 1, triggered[:restart]
-      assert_equal 1, triggered[:status]
-      assert_equal 1, triggered[:stop]
+
+    launcher.handle_args('stop') do |pid|
+      triggered[:stop] << pid
     end
+    
+    assert triggered[:start]
+    assert_equal 1, triggered[:start].length
+
+
+    assert triggered[:restart]
+    assert_equal 1, triggered[:restart].length
+    refute_equal triggered[:start], triggered[:restart]
+
+    assert_equal triggered[:start] + triggered[:restart], triggered[:status]
+
+    assert_equal triggered[:restart], triggered[:stop]
   end
 end

data/test/unit/pigeon_option_accessor_test.rb

@@ -6,10 +6,10 @@ class OptionClass
   option_accessor :single_option
   option_accessor :multi1, :multi2
   option_accessor :option_with_default,
-    :default => :example_default
+    default: :example_default
 
   option_accessor :boolean_option,
-    :boolean => true
+    boolean: true
 
   self.single_option = :single_option_default
 end
@@ -17,7 +17,7 @@ end
 class OptionSubclass < OptionClass
 end
 
-class PigeonOptionAccessorTest < Test::Unit::TestCase
+class PigeonOptionAccessorTest < Minitest::Test
   def test_class_and_instance_chaining
     assert_equal :single_option_default, OptionClass.single_option
     

data/test/unit/pigeon_processor_test.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.join(*%w[ .. helper ]), File.dirname(__FILE__))
 
-class PigeonProcessorTest < Test::Unit::TestCase
+class PigeonProcessorTest < Minitest::Test
   class TaggedTask < Pigeon::Task
     attr_accessor :tag
     attr_reader :last_task
@@ -9,6 +9,10 @@ class PigeonProcessorTest < Test::Unit::TestCase
       super(options)
       @tag = tag
     end
+
+    def state_initialized!
+      transition_to_state(:finished)
+    end
     
     def inspect
       "<#{@tag}>"
@@ -46,7 +50,7 @@ class PigeonProcessorTest < Test::Unit::TestCase
       end
     
       assert_equal false, processor.task?
-    
+
       queue << TaggedTask.new(0)
     
       assert_eventually(1) do
@@ -71,16 +75,18 @@ class PigeonProcessorTest < Test::Unit::TestCase
   end
 
   def test_on_backlog
-    queue = Pigeon::Queue.new
-    
-    100.times do |n|
-      queue << TaggedTask.new(n)
-    end
-    
-    processor = Pigeon::Processor.new(queue)
-    
-    assert_eventually(5) do
-      queue.empty?
+    engine do
+      queue = Pigeon::Queue.new
+      
+      100.times do |n|
+        queue << TaggedTask.new(n)
+      end
+      
+      processor = Pigeon::Processor.new(queue)
+      
+      assert_eventually(5) do
+        queue.empty?
+      end
     end
   end
   
@@ -145,7 +151,7 @@ class PigeonProcessorTest < Test::Unit::TestCase
         queue << TaggedTask.new(n)
       end
     
-      assert_eventually(2) do
+      assert_eventually(5) do
         queue.length == count
       end
     

data/test/unit/pigeon_queue_test.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.join(*%w[ .. helper ]), File.dirname(__FILE__))
 
-class PigeonQueueTest < Test::Unit::TestCase
+class PigeonQueueTest < Minitest::Test
   class TaggedTask < Pigeon::Task
     attr_accessor :tag
     

data/test/unit/pigeon_scheduler_test.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.join(*%w[ .. helper ]), File.dirname(__FILE__))
 
-class PigeonSchedulerTest < Test::Unit::TestCase
+class PigeonSchedulerTest < Minitest::Test
   class TaggedTask < Pigeon::Task
     attr_accessor :tag
     

data/test/unit/pigeon_sorted_array_test.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.join(*%w[ .. helper ]), File.dirname(__FILE__))
 
-class PigeonSortedArrayTest < Test::Unit::TestCase
+class PigeonSortedArrayTest < Minitest::Test
   def test_empty_state
     array = Pigeon::SortedArray.new
     
@@ -21,13 +21,13 @@ class PigeonSortedArrayTest < Test::Unit::TestCase
   def test_does_sorting
     array = Pigeon::SortedArray.new
     
-    test_array = [2, 2, 2, 2, 3, 3, 3]
+    test_array = [ 2, 2, 2, 2, 3, 3, 3 ]
     
     test_array.each do |i| 
       array << i
     end
     
-    assert_equal [2, 2, 2, 2, 3, 3, 3], array.to_a
+    assert_equal [ 2, 2, 2, 2, 3, 3, 3 ], array.to_a
   end
   
   def test_does_sorting_with_insertion_in_order

data/test/unit/pigeon_task_test.rb

@@ -1,5 +1,11 @@
 require File.expand_path(File.join(*%w[ .. helper ]), File.dirname(__FILE__))
 
+class TerminateTask < Pigeon::Task
+  def state_initialized!
+    transition_to_state(:finished)
+  end
+end
+
 class ExampleTask < Pigeon::Task
   attr_accessor :triggers
   
@@ -43,10 +49,10 @@ class FailingTask < Pigeon::Task
   end
 end
 
-class PigeonTaskTest < Test::Unit::TestCase
+class PigeonTaskTest < Minitest::Test
   def test_empty_task
     engine do
-      task = Pigeon::Task.new
+      task = TerminateTask.new
     
       reported = 0
     
@@ -68,14 +74,19 @@ class PigeonTaskTest < Test::Unit::TestCase
   end
 
   def test_alternate_engine
-    engine = Pigeon::Engine.new
-    task = Pigeon::Task.new(nil, engine)
-    
-    assert_equal engine.object_id, task.engine.object_id
+    engine do |default_engine|
+      engine = Pigeon::Engine.new
+      
+      refute_equal default_engine.object_id, engine.object_id
+
+      task = Pigeon::Task.new(nil, engine)
+
+      assert_equal engine.object_id, task.engine.object_id
+    end
   end
   
   def test_example_task
-    engine do
+    engine do |launched|
       task = ExampleTask.new
     
       callbacks = [ ]
@@ -137,23 +148,25 @@ class PigeonTaskTest < Test::Unit::TestCase
   end
   
   def test_with_context
-    options = {
-      :example => 'example1',
-      :optional => 1
-    }.freeze
-    
-    task = Pigeon::Task.new(options)
-    
-    assert_equal options, task.context
-    
-    task.context = 'test'
-    
-    assert_equal 'test', task.context
+    engine do
+      options = {
+        example: 'example1',
+        optional: 1
+      }.freeze
+      
+      task = Pigeon::Task.new(options)
+      
+      assert_equal options, task.context
+      
+      task.context = 'test'
+      
+      assert_equal 'test', task.context
+    end
   end
 
   def test_block_notification
     engine do
-      task = Pigeon::Task.new
+      task = TerminateTask.new
 
       states_triggered = [ ]
 
@@ -170,15 +183,17 @@ class PigeonTaskTest < Test::Unit::TestCase
   end
 
   def test_priority_order
-    tasks = (0..10).collect do
-      task = Pigeon::Task.new
+    engine do
+      tasks = (0..10).collect do
+        task = Pigeon::Task.new
 
-      # Trigger generation of default priority value
-      task.priority
+        # Trigger generation of default priority value
+        task.priority
 
-      task 
+        task 
+      end
+      
+      assert_equal tasks.collect(&:object_id), tasks.sort.collect(&:object_id)
     end
-    
-    assert_equal tasks.collect(&:object_id), tasks.sort.collect(&:object_id)
   end
 end

data/test/unit/pigeon_test.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.join(*%w[ .. helper ]), File.dirname(__FILE__))
 
-class TestPigeon < Test::Unit::TestCase
+class TestPigeon < Minitest::Test
   def test_load_module
     assert Pigeon
   end

metadata

@@ -1,30 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: pigeon
 version: !ruby/object:Gem::Version
-  version: 0.9.3
-  prerelease: 
+  version: 1.0.0
 platform: ruby
 authors:
 - tadman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-26 00:00:00.000000000 Z
+date: 2015-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Pigeon is a simple way to get started building an EventMachine engine
@@ -36,7 +75,9 @@ extra_rdoc_files:
 - LICENSE
 - README.md
 files:
-- .document
+- ".document"
+- ".travis.yml"
+- Gemfile
 - LICENSE
 - README.md
 - Rakefile
@@ -70,26 +111,25 @@ files:
 - test/unit/pigeon_test.rb
 homepage: http://github.com/twg/pigeon
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Simple daemonized EventMachine engine framework with plug-in support
 test_files: []