pigeon 0.2.0 → 0.3.0

data/.gitignore

@@ -1,4 +1,5 @@
 *.gem
+*.log
 
 .DS_Store
 *.tmproj

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/bin/launcher.example

@@ -1,54 +1,6 @@
 #!/usr/bin/env ruby
 
-COMMAND_NAME = 'launcher'
-engine = engine
+$LOAD_PATH << File.expand_path(File.join(*%w[ .. lib ]), File.dirname(__FILE__))
+require 'pigeon'
 
-options = {
-  :dir => engine.pid_dir,
-  :debug => true, # ((ENV['RAILS_ENV'] == 'production') ? ENV['PINGITY_DEBUG'] : true),
-  :modules => [ ]
-}
-
-begin
-  case (command)
-  when 'start'
-    engine.start(options) do |pid|
-      puts "Pigeon Engine now running. [%d]" % pid
-    end
-  when 'stop'
-    engine.stop(options) do |pid|
-      if (pid)
-        puts "Pigeon Engine shut down. [%d]" % pid
-      else
-        puts "Pigeon Engine was not running."
-      end
-    end
-  when 'restart'
-    engine.restart(options) do |old_pid, new_pid|
-      if (old_pid)
-        puts "Pigeon Engine terminated. [%d]" % old_pid
-      end
-      puts "Pigeon Engine now running. [%d]" % new_pid
-    end
-  when 'status'
-    engine.status(options) do |pid|
-      if (pid)
-        puts "Pigeon Engine running. [%d]" % pid
-      else
-        puts "Pigeon Engine is not running."
-      end
-    end
-  when 'run'
-    options[:logger] = Pigeon::Logger.new(STDOUT)
-  
-    engine.run(options) do |pid|
-      puts "Pigeon Engine now running. [%d]" % pid
-      puts "Use ^C to terminate."
-    end
-  else
-    puts "Usage: #{COMMAND_NAME} [start|stop|restart|status|run]"
-  end
-rescue Interrupt
-  puts "Shutting down."
-  exit(0)
-end
+Pigeon::Launcher.new(Pigeon::Engine).handle_args(ARGV)

data/lib/pigeon.rb

@@ -1,7 +1,12 @@
 module Pigeon
+  # == Autoloads ============================================================
+  
   autoload(:Engine, 'pigeon/engine')
-  autoload(:Queue, 'pigeon/queue')
+  autoload(:Launcher, 'pigeon/launcher')
+  autoload(:OptionAccessor, 'pigeon/option_accessor')
   autoload(:Pidfile, 'pigeon/pidfile')
+  autoload(:Queue, 'pigeon/queue')
   autoload(:Support, 'pigeon/support')
-  autoload(:Logger, 'pigeon/logger')
 end
+
+require 'pigeon/logger'

data/lib/pigeon/engine.rb

@@ -1,5 +1,6 @@
 require 'eventmachine'
 require 'socket'
+require 'digest/sha1'
 
 class Pigeon::Engine
   # == Submodules ===========================================================
@@ -7,9 +8,43 @@ class Pigeon::Engine
   class RuntimeError < Exception
   end
   
+  class ConfigurationError < Exception
+  end
+  
+  # == Extensions ==========================================================
+  
+  extend Pigeon::OptionAccessor
+  
   # == Properties ===========================================================
   
-  attr_reader :logger
+  option_accessor :logger
+
+  option_accessor :name
+  option_accessor :pid_file_name
+  option_accessor :foreground,
+    :boolean => true
+  option_accessor :debug,
+    :boolean => true
+    
+  option_accessor :engine_log_name,
+    :default => 'engine.log'
+  option_accessor :engine_logger
+
+  option_accessor :query_log_name,
+    :default => 'query.log'
+  option_accessor :query_logger
+  
+  option_accessor :try_pid_dirs,
+    :default => %w[
+      /var/run
+      /tmp
+    ].freeze
+
+  option_accessor :try_log_dirs,
+    :default => %w[
+      /var/log
+      /tmp
+    ].freeze
 
   # == Constants ============================================================
   
@@ -20,33 +55,45 @@ class Pigeon::Engine
     before_stop
     after_stop
   ].collect(&:to_sym).freeze
-  
-  PID_DIR = [
-    File.expand_path(File.join(*%w[ .. .. .. .. shared run ]), File.dirname(__FILE__)),
-    '/var/run',
-    '/tmp'
-  ].find { |path| File.exist?(path) and File.writable?(path) }
-
-  LOG_DIR = [
-    File.expand_path(File.join(*%w[ .. .. .. .. shared log ] ), File.dirname(__FILE__)),
-    File.expand_path(File.join(*%w[ .. .. log ]), File.dirname(__FILE__)),
-    '/tmp'
-  ].find { |path| File.exist?(path) and File.writable?(path) }
-  
-  DEFAULT_OPTIONS = {
-    :pid_file => File.expand_path('pigeon-engine.pid', PID_DIR)
-  }.freeze
 
   # == Class Methods ========================================================
   
-  def self.options_with_defaults(options = nil)
-    options ? DEFAULT_OPTIONS.merge(options) : DEFAULT_OPTIONS
+  # Returns the human-readable name of this engine. Defaults to the name
+  # of the engine class, but can be replaced to customize a subclass.
+  def self.name
+    @name or self.to_s.gsub(/::/, ' ')
+  end
+  
+  # Returns the name of the PID file to use. The full path to the file
+  # is specified elsewhere.
+  def self.pid_file_name
+    @pid_file_name or self.name.downcase.gsub(/ /, '-') + '.pid'
+  end
+  
+  # Returns the full path to the PID file that should be used to track
+  # the running status of this engine.
+  def self.pid_file_path
+    @pid_file_path ||= begin
+      if (path = Pigeon::Support.find_writable_directory(self.try_pid_dirs))
+        File.expand_path(self.pid_file_name, path)
+      else
+        raise ConfigurationError, "Could not find a writable directory for the PID file in: #{self.try_pid_dirs.join(' ')}"
+      end
+    end
   end
 
-  def self.launch_with_options(options = nil)
+  # Returns the full path to the directory used to store logs.
+  def self.log_dir
+    @log_file_path ||= Pigeon::Support.find_writable_directory(self.try_log_dirs)
+  end
+  
+  # Launches the engine with the specified options
+  def self.launch(options = nil)
     EventMachine.run do
-      engine = new(options_with_defaults(options))
-
+      engine = new(options)
+      
+      yield(engine) if (block_given?)
+    
       Signal.trap('INT') do
         engine.terminate
       end
@@ -55,35 +102,30 @@ class Pigeon::Engine
     end
   end
   
-  def self.pid_dir
-    PID_DIR
-  end
-  
-  def self.pid_file(options = nil)
-    Pigeon::Pidfile.new(options_with_defaults(options)[:pid_file])
+  def self.pid_file
+    @pid_file ||= Pigeon::Pidfile.new(self.pid_file_path)
   end
 
   def self.start(options = nil)
     pid = Pigeon::Support.daemonize do
-      launch_with_options(options)
+      launch(options)
     end
 
-    pid_file(options).create!(pid)
+    pid_file.create!(pid)
 
     yield(pid) if (block_given?)
     
     pid
   end
 
-  def self.run(options = nil)
+  def self.run
     yield($$) if (block_given?)
 
-    launch_with_options((options || { }).merge(:foreground => true))
+    launch(:foreground => true)
   end
   
-  def self.stop(options = nil)
-    pf = pid_file(options)
-    pid = pf.running
+  def self.stop
+    pid = self.pid_file.running
     
     if (pid)
       begin
@@ -92,7 +134,8 @@ class Pigeon::Engine
         # No such process exception
         pid = nil
       end
-      pf.remove!
+
+      pid_file.remove!
     end
     
     pid = pid.to_i if (pid)
@@ -102,28 +145,41 @@ class Pigeon::Engine
     pid
   end
 
-  def self.restart(options = nil)
-    self.stop(options)
-    self.start(options)
+  def self.restart
+    self.stop
+    self.start
   end
   
-  def self.status(options = nil)
-    pid = pid_file(options).running
+  def self.running?
+    pid_file.running
+  end
+  
+  def self.status
+    pid = pid_file.running
     
     yield(pid) if (block_given?)
     
     pid
   end
+  
+  # Returns a default logger for the engine.
+  def self.engine_logger
+    @engine_logger ||= begin
+      f = File.open(File.expand_path(self.engine_log_name, self.log_dir), 'w+')
+      f.sync = true
 
-  def self.sql_logger
-    f = File.open(File.expand_path("query.log", LOG_DIR), 'w+')
-    f.sync = true
-    
-    Pigeon::Logger.new(f)
+      Pigeon::Logger.new(f)
+    end
   end
-  
-  def self.log_dir
-    LOG_DIR
+
+  # Returns a default logger for queries.
+  def self.query_logger
+    @query_logger ||= begin
+      f = File.open(File.expand_path(self.query_log_name, self.log_dir), 'w+')
+      f.sync = true
+    
+      Pigeon::Logger.new(f)
+    end
   end
 
   # == Instance Methods =====================================================
@@ -131,35 +187,47 @@ class Pigeon::Engine
   def initialize(options = nil)
     @options = options || { }
     
-    @task_lock = { }
+    @task_lock = Mutex.new
+    @task_locks = { }
 
-    @logger = @options[:logger] || Pigeon::Logger.new(File.open(File.expand_path('engine.log', LOG_DIR), 'w+'))
-    
-    @logger.level = Pigeon::Logger::DEBUG if (@options[:debug])
+    self.logger ||= self.engine_logger
+    self.logger.level = Pigeon::Logger::DEBUG if (self.debug?)
     
     @queue = { }
     
     run_chain(:after_initialize)
   end
 
+  # Returns the hostname of the system this engine is running on.
+  def host
+    Socket.gethostname
+  end
+
+  # Returns a unique 160-bit identifier for this engine expressed as a 40
+  # character hexadecimal string. The first 32-bit sequence is a timestamp
+  # so these numbers increase over time and can be used to identify when
+  # a particular instance was launched.
+  def id
+    @id ||= '%8x%s' % [
+      Time.now.to_i,
+      Digest::SHA1.hexdigest(
+        '%.8f%8x' % [ Time.now.to_f, rand(1 << 32) ]
+      )[0, 32]
+    ]
+  end
+
+  # Handles the run phase of the engine, triggers the before_start and
+  # after_start events accordingly.
   def run
     run_chain(:before_start)
 
     STDOUT.sync = true
 
-    @logger.info("Engine \##{id} Running")
+    logger.info("Engine \##{id} Running")
     
     run_chain(:after_start)
   end
 
-  def host
-    Socket.gethostname
-  end
-
-  def id
-    @id ||= '%8x%8x' % [ Time.now.to_i, rand(1 << 32) ]
-  end
-  
   # Used to periodically execute a task or block. When giving a task name,
   # a method by that name is called, otherwise a block must be supplied.
   # An interval can be specified in seconds, or will default to 1.
@@ -177,19 +245,20 @@ class Pigeon::Engine
     end
   end
   
+  # This is a somewhat naive locking mechanism that may break down
+  # when two requests are fired off within a nearly identical period.
+  # For now, this achieves a general purpose solution that should work
+  # under most circumstances. Refactor later to improve.
   def task_lock(task_name)
-    # NOTE: This is a somewhat naive locking mechanism that may break down
-    #       when two requests are fired off within a nearly identical period.
-    #       For now, this achieves a general purpose solution that should work
-    #       under most circumstances. Refactor later to improve.
-    
-    return if (@task_lock[task_name])
-    
-    @task_lock[task_name] = true
+    @task_lock.synchronize do
+      @task_locks[task_name] ||= Mutex.new
+    end
     
-    yield if (block_given?)
+    return if (@task_locks[task_name].locked?)
     
-    @task_lock[task_name] = false
+    @task_lock[task_name].synchronize do
+      yield if (block_given?)
+    end
   end
 
   def timer(interval, &block)
@@ -202,21 +271,27 @@ class Pigeon::Engine
     EventMachine::PeriodicTimer.new(interval, &block)
   end
   
-  # Used to defer a block of work for near-immediate execution. Uses the
-  # EventMachine#defer method but is not as efficient as the queue method.
+  # Used to defer a block of work for near-immediate execution. Is a 
+  # wrapper around EventMachine#defer and does not perform as well as using
+  # the alternate queue method.
   def defer(&block)
     EventMachine.defer(&block)
   end
   
-  # Shuts down the engine.
+  # Shuts down the engine. Will also trigger the before_stop and after_stop
+  # events.
   def terminate
     run_chain(:before_stop)
+
     EventMachine.stop_event_loop
+
     run_chain(:after_stop)
   end
   
   # Used to queue a block for immediate processing on a background thread.
-  # An optional queue name can be used to sequence tasks properly.
+  # An optional queue name can be used to sequence tasks properly. The main
+  # queue has a large number of threads, while the named queues default
+  # to only one so they can be processed sequentially.
   def queue(name = :default, &block)
     target_queue = @queue[name] ||= Pigeon::Queue.new(name == :default ? nil : 1)
     
@@ -251,10 +326,12 @@ class Pigeon::Engine
     end
   end
 
+  # Returns true if the debug option was set, false otherwise.
   def debug?
     !!@options[:debug]
   end
   
+  # Returns true if running in the foreground, false otherwise.
   def foreground?
     !!@options[:foreground]
   end

data/lib/pigeon/launcher.rb

@@ -0,0 +1,79 @@
+class Pigeon::Launcher
+  # == Class Methods ========================================================
+  
+  def self.launch(engine, options)
+  end
+    
+  # == Instance Methods =====================================================
+    
+  def initialize(with_engine = Pigeon::Engine)
+    @engine = with_engine
+  end
+  
+  def handle_args(*args)
+    command = args.flatten.first
+
+    begin
+      case (command)
+      when 'start'
+        @engine.start(&method(:start))
+      when 'stop'
+        @engine.stop(&method(:stop))
+      when 'restart'
+        @engine.restart(&method(:restart))
+      when 'status'
+        @engine.status(&method(:status))
+      when 'run'
+        @engine.logger = Pigeon::Logger.new(STDOUT)
+
+        @engine.run(&method(:run))
+      else
+        usage
+      end
+    rescue Interrupt
+      shutdown(pid)
+      exit(0)
+    end
+  end
+  
+  def run(pid)
+    puts "#{@engine.name} now running. [%d]" % pid
+    puts "Use ^C to terminate."
+  end
+  
+  def start(pid)
+    puts "#{@engine.name} now running. [%d]" % pid
+  end
+  
+  def stop(pid)
+    if (pid)
+      puts "#{@engine.name} shut down. [%d]" % pid
+    else
+      puts "#{@engine.name} was not running."
+    end
+  end
+  
+  def status(pid)
+    if (pid)
+      puts "#{@engine.name} running. [%d]" % pid
+    else
+      puts "#{@engine.name} is not running."
+    end
+  end
+  
+  def restart(pid, old_pid)
+    if (old_pid)
+      puts "#{@engine.name} terminated. [%d]" % old_pid
+    end
+
+    puts "#{@engine.name} now running. [%d]" % pid
+  end
+  
+  def shutdown(pid)
+    puts "Shutting down."
+  end
+
+  def usage
+    puts "Usage: #{File.basename($0)} [start|stop|restart|status|run]"
+  end
+end

data/lib/pigeon/option_accessor.rb

@@ -0,0 +1,95 @@
+module Pigeon::OptionAccessor
+  # Given a list of names, this declares an option accessor which works like
+  # a combination of cattr_accessor and attr_accessor, except that defaults
+  # defined for a class will propagate down to the instances and subclasses,
+  # but these defaults can be over-ridden in subclasses and instances
+  # without interference. Optional hash at end of list can be used to set:
+  #  * :default => Assigns a default value which is otherwise nil
+  def option_accessor(*args)
+    option_reader(*args)
+    option_writer(*args)
+  end
+
+  # Given a list of names, this declares an option reader which works like
+  # a combination of cattr_reader and attr_reader, except that defaults
+  # defined for a class will propagate down to the instances and subclasses,
+  # but these defaults can be over-ridden in subclasses and instances
+  # without interference. Optional hash at end of list can be used to set:
+  #  * :default => Assigns a default value which is otherwise nil
+  def option_reader(*names)
+    names = [ names ].flatten.compact
+    options = names.last.is_a?(Hash) ? names.pop : { }
+    
+    names.each do |name|
+      iv = :"@#{name}"
+
+      (class << self; self; end).class_eval do
+        if (options[:boolean])
+          define_method(:"#{name}?") do
+            iv_value = instance_variable_get(iv)
+
+            !!(iv_value.nil? ? (self.superclass.respond_to?(name) ? self.superclass.send(name) : nil) : iv_value)
+          end
+        end
+
+        define_method(name) do
+          iv_value = instance_variable_get(iv)
+          
+          iv_value.nil? ? (self.superclass.respond_to?(name) ? self.superclass.send(name) : nil) : iv_value
+        end
+      end
+    
+      define_method(name) do
+        iv_value = instance_variable_get(iv)
+
+        iv_value.nil? ? self.class.send(name) : iv_value
+      end
+
+      if (options[:boolean])
+        define_method(:"#{name}?") do
+          iv_value = instance_variable_get(iv)
+
+          !!(iv_value.nil? ? self.class.send(name) : iv_value)
+        end
+      end
+      
+      instance_variable_set(iv, options[:default])
+    end
+  end
+
+  # Given a list of names, this declares an option writer which works like
+  # a combination of cattr_writer and attr_writer, except that defaults
+  # defined for a class will propagate down to the instances and subclasses,
+  # but these defaults can be over-ridden in subclasses and instances
+  # without interference.
+  def option_writer(*names)
+    names = [ names ].flatten.compact
+    options = names.last.is_a?(Hash) ? names.pop : { }
+    
+    names.each do |name|
+      iv = :"@#{name}"
+
+      (class << self; self; end).class_eval do
+        if (options[:boolean])
+          define_method(:"#{name}=") do |value|
+            instance_variable_set(iv, value.nil? ? nil : !!value)
+          end
+        else
+          define_method(:"#{name}=") do |value|
+            instance_variable_set(iv, value)
+          end
+        end
+      end
+    
+      if (options[:boolean])
+        define_method(:"#{name}=") do |value|
+          instance_variable_set(iv, value.nil? ? nil : !!value)
+        end
+      else
+        define_method(:"#{name}=") do |value|
+          instance_variable_set(iv, value)
+        end
+      end
+    end
+  end
+end

data/lib/pigeon/support.rb

@@ -1,5 +1,8 @@
 module Pigeon::Support
-  def self.daemonize
+  # Uses the double-fork method to create a fully detached background
+  # process. Returns the process ID of the created process. May throw an
+  # exception if these processes could not be created.
+  def daemonize
     rfd, wfd = IO.pipe
     
     forked_pid = fork do
@@ -18,4 +21,15 @@ module Pigeon::Support
     
     daemon_pid.to_i
   end
+  
+  # Finds the first directory in the given list that exists and is
+  # writable. Returns nil if none match.
+  def find_writable_directory(*list)
+    list.flatten.compact.find do |dir|
+      File.exist?(dir) and File.writable?(dir)
+    end
+  end
+    
+  # Make all methods callable directly without having to include it
+  extend self
 end

data/pigeon.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{pigeon}
-  s.version = "0.2.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["tadman"]
-  s.date = %q{2010-10-05}
+  s.date = %q{2010-10-19}
   s.default_executable = %q{launcher.example}
   s.description = %q{Pigeon is a simple way to get started building an EventMachine engine that's intended to run as a background job.}
   s.email = %q{github@tadman.ca}
@@ -28,7 +28,9 @@ Gem::Specification.new do |s|
      "bin/launcher.example",
      "lib/pigeon.rb",
      "lib/pigeon/engine.rb",
+     "lib/pigeon/launcher.rb",
      "lib/pigeon/logger.rb",
+     "lib/pigeon/option_accessor.rb",
      "lib/pigeon/pidfile.rb",
      "lib/pigeon/queue.rb",
      "lib/pigeon/support.rb",
@@ -36,6 +38,8 @@ Gem::Specification.new do |s|
      "test/helper.rb",
      "test/test_pigeon.rb",
      "test/test_pigeon_engine.rb",
+     "test/test_pigeon_launcher.rb",
+     "test/test_pigeon_option_accessor.rb",
      "test/test_pigeon_queue.rb"
   ]
   s.homepage = %q{http://github.com/tadman/pigeon}
@@ -47,6 +51,8 @@ Gem::Specification.new do |s|
     "test/helper.rb",
      "test/test_pigeon.rb",
      "test/test_pigeon_engine.rb",
+     "test/test_pigeon_launcher.rb",
+     "test/test_pigeon_option_accessor.rb",
      "test/test_pigeon_queue.rb"
   ]
 

data/test/helper.rb

@@ -4,8 +4,15 @@ require 'test/unit'
 $LOAD_PATH.unshift(File.expand_path(*%w[ .. lib ]), File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
+require 'rubygems'
+
+if (Gem.available?('eventmachine'))
+  gem 'eventmachine'
+else
+  raise "EventMachine gem is not installed."
+end
+
 require 'pigeon'
 
 class Test::Unit::TestCase
-  # ...
 end

data/test/test_pigeon_engine.rb

@@ -28,35 +28,39 @@ end
 
 class CallbackTestEngine < Pigeon::Engine
   after_initialize do
-    self.track(:after_initialize)
+    track(:after_initialize)
   end
   
   before_start do
-    self.track(:before_start)
+    track(:before_start)
   end
   
   after_start do
-    self.track(:after_start)
+    track(:after_start)
   end
   
   before_stop do
-    self.track(:before_stop)
+    track(:before_stop)
   end
   
   after_stop do
-    self.track(:after_stop)
+    track(:after_stop)
+
     @options[:pipe].close
   end
   
   def track(callback)
-    pipe = @options[:pipe]
-
-    pipe.puts(callback.to_s)
-    pipe.flush
+    @options[:pipe].puts(callback.to_s)
+    @options[:pipe].flush
   end
 end
 
 class TestPigeonEngine < Test::Unit::TestCase
+  def test_default_options
+    assert TestEngine.engine_logger
+    assert TestEngine.engine_logger.is_a?(Logger)
+  end
+  
   def test_example_subclass
     engine_pid = nil
     
@@ -122,10 +126,15 @@ class TestPigeonEngine < Test::Unit::TestCase
     
     write_fd.close
     
+    reported_status = false
+    
     CallbackTestEngine.status do |pid|
       assert_equal engine_pid, pid
+      reported_status = true
     end
     
+    assert reported_status
+    
     CallbackTestEngine.stop do |pid|
       assert_equal engine_pid, pid
     end

data/test/test_pigeon_launcher.rb

@@ -0,0 +1,51 @@
+require File.expand_path(File.join(*%w[ helper ]), File.dirname(__FILE__))
+
+class PigeonLauncherTest < Test::Unit::TestCase
+  def test_default_launcher
+    pid = Pigeon::Launcher.launch
+    
+    assert pid
+    assert Pigeon::Engine.running?
+    
+    Pigeon::Launcher.stop
+    
+    assert !Pigeon::Engine.running?
+  end
+
+  def test_triggers
+    triggered = Hash.new do |h, k|
+      h[k] = 0
+    end
+    
+    Pigeon::Launcher.new(Pigeon::Engine).handle_args('start') do
+      start do
+        triggered[:start] += 1
+      end
+    end
+
+    Pigeon::Launcher.new(Pigeon::Engine).handle_args('restart') do
+      restart do
+        triggered[:restart] += 1
+      end
+    end
+
+    Pigeon::Launcher.new(Pigeon::Engine).handle_args('status') do
+      status do
+        triggered[:status] += 1
+      end
+    end
+
+    Pigeon::Launcher.new(Pigeon::Engine).handle_args('stop') do
+      stop do
+        triggered[:stop] += 1
+      end
+    end
+    
+    # FIX: Test `run`
+    
+    assert_equal 1, triggered[:start]
+    assert_equal 1, triggered[:restart]
+    assert_equal 1, triggered[:status]
+    assert_equal 1, triggered[:stop]
+  end
+end

data/test/test_pigeon_option_accessor.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.join(*%w[ helper ]), File.dirname(__FILE__))
+
+class OptionClass
+  extend Pigeon::OptionAccessor
+
+  option_accessor :single_option
+  option_accessor :multi1, :multi2
+  option_accessor :option_with_default,
+    :default => :example_default
+
+  option_accessor :boolean_option,
+    :boolean => true
+
+  self.single_option = :single_option_default
+end
+
+class OptionSubclass < OptionClass
+end
+
+class PigeonOptionAccessorTest < Test::Unit::TestCase
+  def test_class_and_instance_chaining
+    assert_equal :single_option_default, OptionClass.single_option
+    
+    instance = OptionClass.new
+    
+    assert_equal :single_option_default, instance.single_option
+    
+    OptionClass.single_option = :new_default
+    
+    assert_equal :new_default, instance.single_option
+    
+    instance.single_option = :override
+    
+    assert_equal :override, instance.single_option
+    assert_equal :new_default, OptionClass.single_option
+    
+    # Reset to defaults for next test
+    OptionClass.single_option = :single_option_default
+  end
+  
+  def test_subclass_inheritance
+    assert_equal :single_option_default, OptionSubclass.single_option
+    
+    OptionSubclass.single_option = :subclass_default
+    
+    assert_equal :subclass_default, OptionSubclass.single_option
+    assert_equal :single_option_default, OptionClass.single_option
+
+    class_instance = OptionClass.new
+    subclass_instance = OptionSubclass.new
+    
+    assert_equal :subclass_default, subclass_instance.single_option
+    assert_equal :single_option_default, class_instance.single_option
+
+    # Reset to defaults for next test
+    OptionSubclass.single_option = nil
+  end
+
+  def test_boolean_option
+    assert_equal nil, OptionClass.multi1
+    
+    instance = OptionClass.new
+    
+    instance.multi1 = false
+    
+    assert_equal false, instance.multi1
+    assert_equal nil, OptionClass.multi1
+    
+    assert_equal nil, instance.multi2
+  end
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - tadman
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-05 00:00:00 -04:00
+date: 2010-10-19 00:00:00 -04:00
 default_executable: launcher.example
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -49,7 +49,9 @@ files:
 - bin/launcher.example
 - lib/pigeon.rb
 - lib/pigeon/engine.rb
+- lib/pigeon/launcher.rb
 - lib/pigeon/logger.rb
+- lib/pigeon/option_accessor.rb
 - lib/pigeon/pidfile.rb
 - lib/pigeon/queue.rb
 - lib/pigeon/support.rb
@@ -57,6 +59,8 @@ files:
 - test/helper.rb
 - test/test_pigeon.rb
 - test/test_pigeon_engine.rb
+- test/test_pigeon_launcher.rb
+- test/test_pigeon_option_accessor.rb
 - test/test_pigeon_queue.rb
 has_rdoc: true
 homepage: http://github.com/tadman/pigeon
@@ -94,4 +98,6 @@ test_files:
 - test/helper.rb
 - test/test_pigeon.rb
 - test/test_pigeon_engine.rb
+- test/test_pigeon_launcher.rb
+- test/test_pigeon_option_accessor.rb
 - test/test_pigeon_queue.rb