perennial 1.0.0.2 → 1.0.1

data/README.md

@@ -0,0 +1,23 @@
+# Perennial - a Ruby Event-driven application Library #
+
+Perennial is yet another god damned event library / framework
+for Ruby, built on top of EventMachine. The whole goal of Perennial
+is to make it easy to build a particular style / class of application
+such as [Marvin](http://github.com/Sutto/marvin). Most of the code
+has been extracted from building Marvin (and later, BirdGrinder - like
+Marvin but for twitter). 
+
+Applications built for Perennial are devised around the concept of 'clients'
+and 'handlers'. Clients are things which handle the actual processing (e.g. 
+Marvin's IRC client takes the IRC protocol and converts it into events) and
+handlers respond to messages. In practice, it's an approach inspired by Rack
+in that we do the simplest thing's possible.
+
+Since each event processed by a handler is incredibly simple (a symbol for a name
+and a hash of associated options / details), and there are typically few requirements
+(e.g. a handler only typically needs to define the 'handle' method) it
+makes it relatively easy to build your application how you like.
+
+In other words, Perennial is mainly a bunch of useful mixings (Dispatchable,
+Hookable, Delegateable) which fit in with some evented application design 
+along with the framework for building applications around this design.

data/lib/perennial/dispatchable.rb

@@ -59,6 +59,8 @@ module Perennial
           Logger.debug "Dispatching #{name} event (#{dispatch_queue.size} queued - on #{self.class.name})"
           # Add ourselves to the queue
           @dispatching = true
+          # TODO: improve performance. This should be dispatched per-request cycle.
+          pre_dispatching
           begin
             # The full handler name is the method we call given it exists.
             full_handler_name = :"handle_#{name.to_s.underscore}"
@@ -88,13 +90,20 @@ module Perennial
             Logger.log_exception(e)
           end
           @dispatching = false
-          dispatch(*@dispatch_queue.shift) unless dispatch_queue.empty?
+          dispatch(*@dispatch_queue.shift) if dispatch_queue.present?
+          post_dispatching
         else
           Logger.debug "Adding #{name} event to the end of the queue (on #{self.class.name})"
           dispatch_queue << [name, opts]
         end
       end
       
+      def pre_dispatching
+      end
+      
+      def post_dispatching
+      end
+      
     end
     
     module ClassMethods

data/lib/perennial/jeweler_ext.rb

@@ -0,0 +1,75 @@
+module Perennial
+  module JewelerExt
+    # Adds in utility messages to make it easier to manage versioning.
+    
+    class << self
+      attr_accessor :version_array, :library_file
+    end
+    
+    module Versioning
+      
+      def write
+        contents = File.read(main_library_file)
+        contents.gsub!(/(VERSION\s+=\s+)(\[\d+\,\s*\d+\,\s*\d+(?:\,\s*\d+)?\])/) do |m|
+          "#{$1}#{array.inspect}"
+        end
+        File.open(main_library_file, "w+") do |f|
+          f.write(contents)
+        end
+      end
+      
+      def array
+        [@major, @minor, @patch, @build].compact
+      end
+      
+      def to_s
+        items = array
+        items.pop if items[3] == 0
+        items.join(".")
+      end
+      
+      def main_library_file
+        Perennial::JewelerExt.library_file
+      end
+      
+      def parse_version
+        parts = Perennial::JewelerExt.version_array
+        @major = parts[0]
+        @minor = parts[1]
+        @patch = parts[2]
+        @build = parts[3]
+      end
+      
+      def refresh
+        parse_version
+      end
+      
+      def path
+        nil
+      end
+      
+    end
+  end
+end
+
+require 'jeweler' unless defined?(Jeweler)
+
+# Overrides Jeweler to version using our stuff
+
+def Jeweler.versioning_via(file, version_array)
+  Perennial::JewelerExt.library_file  = file
+  Perennial::JewelerExt.version_array = version_array
+  # Extend with the Perennial extensions
+  Jeweler::VersionHelper.class_eval do
+    def initialize(base_dir)
+      extend Perennial::JewelerExt::Versioning
+      parse_version
+    end
+  end
+  # Ensure version exists
+  Jeweler.class_eval do
+    def version_exists?
+      true
+    end
+  end
+end

data/lib/perennial.rb

@@ -9,7 +9,7 @@ require 'perennial/exceptions'
 
 module Perennial
   
-  VERSION = "1.0.0.2"
+  VERSION = [1, 0, 1, 0]
   
   has_library :dispatchable, :hookable, :loader, :logger, :nash,
               :loggable, :manifest, :settings, :argument_parser,

data/test/delegateable_test.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class DelegateableTest < Test::Unit::TestCase
+  
+  context 'basic delegates' do
+    
+    setup do
+      @klass = test_class_for(Perennial::Delegateable)
+      @delegateable = @klass.new
+    end
+    
+    should 'define a delegate= method' do
+      assert @delegateable.respond_to?(:delegate=)
+    end
+    
+    should 'define a delegate_to method' do
+      assert @delegateable.respond_to?(:delegate_to)
+    end
+    
+    should 'let you get the delegate proxy' do
+      @delegateable.delegate_to :awesome
+      assert proxy = @delegateable.delegate
+      assert_nothing_raised { proxy.awesomesauce }
+      assert_nothing_raised { proxy.ninja_party }
+      assert_equal "awesome", proxy.to_s
+    end
+    
+    should 'let you get the real target of the delegate' do
+      @delegateable.delegate_to :awesome
+      assert real = @delegateable.real_delegate
+      assert_raises(NoMethodError) { proxy.awesomesauce }
+      assert_raises(NoMethodError) { proxy.ninja_party }
+      assert_equal "awesome", real.to_s
+    end
+    
+  end
+  
+end

data/test/dispatchable_test.rb

@@ -0,0 +1,212 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class DispatchableTest < Test::Unit::TestCase
+  
+  class ExampleDispatcher
+    include Perennial::Dispatchable
+  end
+  
+  class ExampleHandlerA
+    
+    attr_accessor :messages
+    
+    def initialize
+      @messages = []
+    end
+    
+    def handle(name, opts)
+      @messages << [name, opts]
+    end
+    
+  end
+
+  class ExampleHandlerB < ExampleHandlerA; end
+  
+  class ExampleHandlerC
+    attr_reader :max_count, :messages, :call_stack
+    def initialize(d)
+      @messages = []
+      @max_count = 0
+      @current_count = 0
+      @dispatcher = d
+      @call_stack = []
+    end
+    
+    def handle(name, opts)
+      @call_stack << "start-#{name}"
+      @current_count += 1
+      @messages << name
+      @dispatcher.dispatch(:b) if name == :a
+      @max_count = @current_count if @current_count > @max_count
+      @current_count -= 1
+      @call_stack << "end-#{name}"
+    end
+    
+  end
+  
+  class RegisterableHandler
+    
+    def registered=(value)
+      @registered = value
+    end
+    
+    def registered?
+      @registered ||= false
+    end
+    
+    def handle(name, opts = {})
+    end
+    
+  end
+  
+  context 'marking a class as dispatchable' do
+    
+    setup do
+      @dispatcher = ExampleDispatcher.new
+    end
+    
+    should 'define a dispatch method' do
+      assert @dispatcher.respond_to?(:dispatch)
+    end
+    
+    should 'require atleast a name for dispatch' do
+      assert_equal -2, @dispatcher.method(:dispatch).arity
+    end
+    
+  end
+  
+  context 'when registering handlers' do
+    
+    setup do
+      @dispatcher = test_class_for(Perennial::Dispatchable)
+    end
+    
+    should 'append a handler using register_handler' do
+      assert_equal [], @dispatcher.handlers
+      @dispatcher.register_handler(handler = ExampleHandlerA.new)
+      assert_equal [handler], @dispatcher.handlers
+    end
+    
+    should 'batch assign handlers on handlers= using register_handler' do
+      handlers = [ExampleHandlerA.new, ExampleHandlerB.new]
+      assert_equal [], @dispatcher.handlers
+      @dispatcher.handlers = handlers
+      assert_equal handlers, @dispatcher.handlers
+    end
+    
+    should 'return all handlers via the handlers class method' do
+      handlers = [ExampleHandlerA.new, ExampleHandlerB.new]
+      @dispatcher.handlers = handlers
+      assert_equal handlers, @dispatcher.handlers
+    end
+    
+    should 'make handlers available to myself and all subclasses' do
+      # Set A
+      dispatcher_a = class_via(@dispatcher)
+      dispatcher_a.register_handler(handler_a = ExampleHandlerA.new)
+      # Set B
+      dispatcher_b = class_via(dispatcher_a)
+      dispatcher_b.register_handler(handler_b = ExampleHandlerA.new)
+      # Set C
+      dispatcher_c = class_via(dispatcher_b)
+      dispatcher_c.register_handler(handler_c = ExampleHandlerA.new)
+      # Set D
+      dispatcher_d = class_via(dispatcher_a)
+      dispatcher_d.register_handler(handler_d = ExampleHandlerB.new)
+      # Actual Assertions
+      assert_equal [],                                @dispatcher.handlers
+      assert_equal [handler_a],                       dispatcher_a.handlers
+      assert_equal [handler_a, handler_b],            dispatcher_b.handlers
+      assert_equal [handler_a, handler_b, handler_c], dispatcher_c.handlers
+      assert_equal [handler_a, handler_d],            dispatcher_d.handlers
+    end
+    
+  end
+  
+  context 'dispatching events' do
+    
+    setup do
+      @dispatcher = class_via(ExampleDispatcher).new
+      @handler    = ExampleHandlerA.new
+      @dispatcher.class.register_handler @handler
+    end
+    
+    should 'attempt to call handle_[event_name] on itself' do
+      mock(@dispatcher).respond_to?(:handle_sample_event) { true }
+      mock(@dispatcher).handle_sample_event(:awesome => true, :sauce => 2)
+      @dispatcher.dispatch :sample_event, :awesome => true, :sauce => 2
+    end
+    
+    should 'attempt to call handle_[event_name] on each handler' do
+      mock(@handler).respond_to?(:handle_sample_event) { true }
+      mock(@handler).handle_sample_event(:awesome => true, :sauce => 2)
+      @dispatcher.dispatch :sample_event, :awesome => true, :sauce => 2
+    end
+    
+    should 'call handle on each handler if handle_[event_name] isn\'t defined' do
+      mock(@handler).respond_to?(:handle_sample_event) { false }
+      mock(@handler).handle(:sample_event, :awesome => true, :sauce => 2)
+      @dispatcher.dispatch :sample_event, :awesome => true, :sauce => 2
+    end
+    
+    should 'let you halt handler processing if you raise HaltHandlerProcessing' do
+      handler_two = ExampleHandlerB.new
+      @dispatcher.class.register_handler handler_two
+      mock(@handler).handle(:sample_event, :awesome => true, :sauce => 2) do
+        raise Perennial::HaltHandlerProcessing
+      end
+      dont_allow(handler_two).handle(:sample_event, :awesome => true, :sauce => 2)
+      @dispatcher.dispatch :sample_event, :awesome => true, :sauce => 2
+    end
+    
+    should 'log exceptions when encountered and not crash'
+    
+  end
+  
+  context 'dispatching nested events' do
+    
+    setup do
+      @dispatcher = class_via(ExampleDispatcher).new
+      @handler    = ExampleHandlerC.new(@dispatcher)
+      @dispatcher.class.register_handler @handler
+      @dispatcher.dispatch :a
+    end
+    
+    should 'call them in the correct order' do
+      assert_equal [:a, :b], @handler.messages
+    end
+    
+    should 'only call 1 dispatch at a time' do
+      assert_equal 1, @handler.max_count
+    end
+    
+    should 'finish a before dispatching b' do
+      assert_equal ["start-a", "end-a", "start-b", "end-b"], @handler.call_stack
+    end
+    
+  end
+  
+  context 'registering handlers' do
+    
+    setup do
+      @dispatcher = class_via(ExampleDispatcher).new
+      @handler    = class_via(RegisterableHandler).new
+    end
+    
+    should 'default to not being registered' do
+      assert !@handler.registered?
+    end
+    
+    should 'set registered on register_handler' do
+      @dispatcher.class.register_handler @handler
+      assert @handler.registered?
+    end
+    
+    should 'call registered= on the handler' do
+      mock(@handler).registered = true
+      @dispatcher.class.register_handler @handler
+    end
+    
+  end
+  
+end

data/test/hookable_test.rb

@@ -0,0 +1,61 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class HookableTest < Test::Unit::TestCase
+  
+  context 'Hookable Classes' do
+    
+    setup do
+      @hookable_class = test_class_for(Perennial::Hookable)
+    end
+    
+    should 'let you append hooks via append_hook' do
+      assert_equal [], @hookable_class.hooks_for(:awesome)
+      @hookable_class.append_hook(:awesome) { puts "Hello!" }
+      assert_equal 1, @hookable_class.hooks_for(:awesome).size
+    end
+    
+    should 'only append hooks if they aren\'t blank' do
+      @hookable_class.append_hook(:awesome)
+      assert_equal [], @hookable_class.hooks_for(:awesome)
+    end
+    
+    should 'let you get an array of hooks' do
+      @hookable_class.append_hook(:awesome) { puts "A" }
+      @hookable_class.append_hook(:awesome) { puts "B" }
+      assert_equal 2, @hookable_class.hooks_for(:awesome).size
+    end
+    
+    should 'let you invoke hooks' do
+      items = []
+      @hookable_class.append_hook(:awesome) { items << :a }
+      @hookable_class.append_hook(:awesome) { items << :b }
+      @hookable_class.append_hook(:awesome) { items << :c }
+      @hookable_class.invoke_hooks!(:awesome)
+      assert_equal [:a, :b, :c], items
+    end
+    
+    should 'call them in the order they are appended' do
+      items = []
+      @hookable_class.append_hook(:awesome) { items << :a }
+      @hookable_class.append_hook(:awesome) { items << :b }
+      @hookable_class.append_hook(:awesome) { items << :c }
+      @hookable_class.invoke_hooks!(:awesome)
+      [:a, :b, :c].each_with_index do |value, index|
+        assert_equal value, items[index]
+      end
+    end
+    
+    should 'let you define hook accessors' do
+      assert_equal [], @hookable_class.hooks_for(:awesome)
+      assert !@hookable_class.respond_to?(:awesome)
+      assert !@hookable_class.respond_to?(:sauce)
+      @hookable_class.define_hook :awesome, :sauce
+      assert @hookable_class.respond_to?(:awesome)
+      assert @hookable_class.respond_to?(:sauce)
+      @hookable_class.awesome { puts "A" }
+      assert_equal 1, @hookable_class.hooks_for(:awesome).size
+    end
+    
+  end
+  
+end

data/test/loader_test.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), "test_helper")

data/test/loggable_test.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class LoggableTest < Test::Unit::TestCase
+  
+  class ExampleLoggable
+    include Perennial::Loggable
+  end
+  
+  context "Defining a class as loggable" do
+    
+    setup do
+      @example = ExampleLoggable.new
+    end
+    
+    should 'define a logger instance method' do
+      assert @example.respond_to?(:logger)
+    end
+    
+    should 'define a logger class method' do
+      assert ExampleLoggable.respond_to?(:logger)
+    end
+    
+    should 'not define a logger= instance method' do
+      assert !@example.respond_to?(:logger=)
+    end
+    
+    should 'not define a logger= class method' do
+      assert !ExampleLoggable.respond_to?(:logger=)
+    end
+    
+    should 'define logger to be an instance of Perennial::Logger' do
+      assert_equal Perennial::Logger, ExampleLoggable.logger
+      assert_equal Perennial::Logger, @example.logger
+    end
+    
+  end
+  
+end

data/test/logger_test.rb

@@ -0,0 +1,59 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class LoggerTest < Test::Unit::TestCase
+  context 'logger tests' do
+    
+    setup do
+      @root_path = Perennial::Settings.root / "log"
+      Perennial::Logger.log_name = "example.log"
+      FileUtils.mkdir_p @root_path
+    end
+  
+    context 'setting up a logger' do
+    
+      setup { Perennial::Logger.setup! }
+    
+      should 'create the log file file after writing' do
+        Perennial::Logger.fatal "Blergh."
+        assert File.exist?(@root_path / "example.log")
+      end
+    
+      Perennial::Logger::LEVELS.each_key do |level_name|
+        should "define a method for the #{level_name} log level" do
+          assert Perennial::Logger.respond_to?(level_name)
+          assert Perennial::Logger.logger.respond_to?(level_name)
+          assert_equal 1, Perennial::Logger.logger.method(level_name).arity
+        end
+      end
+    
+      should 'have a log exception method' do
+        assert Perennial::Logger.respond_to?(:log_exception)
+        assert Perennial::Logger.logger.respond_to?(:log_exception)
+      end
+      
+      should 'let you configure a dir that logs are loaded from'
+    
+    end
+  
+    context 'writing to the log' do
+      
+      Perennial::Logger::LEVELS.each_key do |level_name|
+        should "let you write to the #{level_name} log level" do
+          Perennial::Logger.verbose = false
+          Perennial::Logger.level = level_name
+          assert_nothing_raised do
+            Perennial::Logger.logger.send(level_name, "An Example Message No. 1")
+          end
+        end
+      end
+      
+    end
+  
+    teardown do
+      log_path = @root_path / "example.log"
+      FileUtils.rm_rf(log_path) if File.exist?(log_path)
+    end
+    
+  end
+  
+end

data/test/proxy_test.rb

@@ -0,0 +1,30 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class ProxyTest < Test::Unit::TestCase
+  
+  context 'basic proxies' do
+    
+    setup do
+      @proxy = Perennial::Proxy.new
+      @proxy.__proxy_target__ = :awesome
+    end    
+    should 'pass through the correct class' do
+      assert_equal Symbol, @proxy.class
+      assert_kind_of Symbol, @proxy
+    end
+    
+    should 'not interfere with equals' do
+      assert @proxy  == :awesome
+    end
+    
+    should 'pass through to_s' do
+      assert_equal "awesome", @proxy.to_s
+    end
+    
+    should 'let you send to an object' do
+      assert_equal "awesome", @proxy.send(:to_s)
+    end
+    
+  end
+  
+end

data/test/settings_test.rb

@@ -0,0 +1,103 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class SettingsTest < Test::Unit::TestCase
+  
+  context 'default settings' do
+    
+    setup do
+      Perennial::Settings.setup!
+    end
+    
+    should "default the application root to the parent folder of perennial" do
+      assert_equal __FILE__.to_pathname.dirname.join("..").expand_path,
+                   Perennial::Settings.root.to_pathname
+      Perennial::Settings.root = "/awesome/sauce"
+      assert_equal "/awesome/sauce", Perennial::Settings.root
+    end
+    
+    should "default daemonized to false" do
+      assert !Perennial::Settings.daemon?
+      Perennial::Settings.daemon = true
+      assert Perennial::Settings.daemon?
+      Perennial::Settings.daemon = false
+      assert !Perennial::Settings.daemon?
+    end
+    
+    should "default the log level to :info" do
+      assert_equal :info, Perennial::Settings.log_level
+      Perennial::Settings.log_level = :debug
+      assert_equal :debug, Perennial::Settings.log_level
+    end
+    
+    should "default verbose to false" do
+      assert !Perennial::Settings.verbose?
+      Perennial::Settings.verbose = true
+      assert Perennial::Settings.verbose?
+      Perennial::Settings.verbose = false
+      assert !Perennial::Settings.verbose?
+    end
+    
+  end
+  
+  context 'loading settings' do
+    
+    setup do
+      config_folder = Perennial::Settings.root / "config"
+      @default_settings = {
+        "default" => {
+          "introduction" => true,
+          "description"  => "Ninjas are Totally Awesome",
+          "channel"      => "#offrails",
+          "users"        => ["Sutto", "njero", "zapnap"]
+        }
+      }
+      FileUtils.mkdir_p(config_folder)
+      File.open(config_folder / "settings.yml", "w+") do |file|
+        file.write(@default_settings.to_yaml)
+      end
+      Perennial::Settings.setup!
+    end
+    
+    should 'load settings from the file' do
+      assert Perennial::Settings.setup?
+      assert_equal @default_settings["default"].symbolize_keys, Perennial::Settings.to_hash
+    end
+    
+    should 'define readers for the settings' do
+      instance = Perennial::Settings.new
+      @default_settings["default"].each_pair do |key, value|
+        assert Perennial::Settings.respond_to?(key.to_sym)
+        assert_equal value, Perennial::Settings.send(key)
+        assert instance.respond_to?(key.to_sym)
+        assert_equal value, instance.send(key)
+      end
+    end
+    
+    should 'let you access settings via hash-style accessors' do
+      @default_settings["default"].each_pair do |key, value|
+        assert_equal value, Perennial::Settings[key]
+        Perennial::Settings[key] = "a-new-value from #{value.inspect}"
+        assert_equal "a-new-value from #{value.inspect}", Perennial::Settings[key]
+      end
+    end
+    
+    should 'define writers for the settings' do
+      instance = Perennial::Settings.new
+      @default_settings["default"].each_pair do |key, value|
+        setter = :"#{key}="
+        assert Perennial::Settings.respond_to?(setter)
+        Perennial::Settings.send(setter, "value #{value.inspect} on class")
+        assert_equal "value #{value.inspect} on class", Perennial::Settings.send(key)
+        assert instance.respond_to?(setter)
+        instance.send(setter, "value #{value.inspect} on instance")
+        assert_equal "value #{value.inspect} on instance", instance.send(key)
+      end
+    end
+    
+    should 'let you configure the lookup key path'
+    
+    should 'let you configure the file settings are loaded from'
+    
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,38 @@
+require 'rubygems'
+
+# Testing dependencies
+require 'test/unit'
+require 'shoulda'
+require 'rr'
+# RedGreen doesn't seem to be needed under 1.9
+require 'redgreen' if RUBY_VERSION < "1.9"
+
+require 'pathname'
+root_directory = Pathname.new(__FILE__).dirname.join("..").expand_path
+require root_directory.join("lib", "perennial")
+require root_directory.join("vendor", "fakefs", "lib", "fakefs")
+
+class Test::Unit::TestCase
+  include RR::Adapters::TestUnit
+  
+  protected
+  
+  # Short hand for creating a class with
+  # a given class_eval block.
+  def class_via(*args, &blk)
+    klass = Class.new(*args)
+    klass.class_eval(&blk) unless blk.blank?
+    return klass
+  end
+  
+  # Short hand for creating a test class
+  # for a set of mixins - give it the modules
+  # and it will include them all.
+  def test_class_for(*mods, &blk)
+    klass = Class.new
+    klass.class_eval { include(*mods) }
+    klass.class_eval(&blk) unless blk.blank?
+    return klass
+  end
+  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: perennial
 version: !ruby/object:Gem::Version 
-  version: 1.0.0.2
+  version: 1.0.1
 platform: ruby
 authors: 
 - Darcy Laycock
@@ -9,35 +9,56 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-25 00:00:00 +08:00
+date: 2009-10-05 00:00:00 +08:00
 default_executable: perennial
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: yard
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
 description: Perennial is a platform for building different applications in Ruby. It uses a controller-based approach with mixins to provide different functionality.
 email: sutto@sutto.net
 executables: 
 - perennial
 extensions: []
 
-extra_rdoc_files: []
-
+extra_rdoc_files: 
+- README.md
 files: 
 - bin/perennial
+- lib/perennial.rb
 - lib/perennial/application.rb
 - lib/perennial/argument_parser.rb
+- lib/perennial/core_ext.rb
 - lib/perennial/core_ext/attribute_accessors.rb
 - lib/perennial/core_ext/blank.rb
 - lib/perennial/core_ext/hash_key_conversions.rb
 - lib/perennial/core_ext/inflections.rb
 - lib/perennial/core_ext/misc.rb
 - lib/perennial/core_ext/proxy.rb
-- lib/perennial/core_ext.rb
 - lib/perennial/daemon.rb
 - lib/perennial/delegateable.rb
 - lib/perennial/dispatchable.rb
 - lib/perennial/exceptions.rb
 - lib/perennial/generator.rb
 - lib/perennial/hookable.rb
+- lib/perennial/jeweler_ext.rb
 - lib/perennial/loader.rb
 - lib/perennial/loggable.rb
 - lib/perennial/logger.rb
@@ -46,20 +67,20 @@ files:
 - lib/perennial/option_parser.rb
 - lib/perennial/reloading.rb
 - lib/perennial/settings.rb
-- lib/perennial.rb
 - templates/application.erb
 - templates/boot.erb
 - templates/rakefile.erb
 - templates/setup.erb
 - templates/test.erb
 - templates/test_helper.erb
-has_rdoc: false
+- README.md
+has_rdoc: true
 homepage: http://sutto.net/
 licenses: []
 
 post_install_message: 
-rdoc_options: []
-
+rdoc_options: 
+- --charset=UTF-8
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -77,9 +98,17 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.2
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: A simple (generally event-oriented) application library for Ruby
-test_files: []
-
+test_files: 
+- test/delegateable_test.rb
+- test/dispatchable_test.rb
+- test/hookable_test.rb
+- test/loader_test.rb
+- test/loggable_test.rb
+- test/logger_test.rb
+- test/proxy_test.rb
+- test/settings_test.rb
+- test/test_helper.rb