Sutto-perennial 1.0.0.0 → 1.0.0.1

data/lib/perennial/application.rb

@@ -74,12 +74,13 @@ module Perennial
       controller_name = controller.to_s.underscore
       controller = controller.to_sym
       command_name = controller_name.gsub("_", "-")
+      parent = self
       add("#{command_name} #{"[PATH]" if !opts[:skip_path]}".strip, description) do |*args|
         options = args.extract_options!
         path = File.expand_path(args[0] || ".")
         Settings.root = path
         if options.delete(:kill)
-          attempt_showing_banner
+          parent.attempt_showing_banner
           puts "Attempting to kill processess for #{command_name}"
           Daemon.kill_all(controller)
         else
@@ -148,7 +149,7 @@ module Perennial
       end
       application.execute args
     end
-    
+  
     def attempt_showing_banner
       if banner.present?
         puts banner

data/lib/perennial.rb

@@ -9,7 +9,7 @@ require 'perennial/exceptions'
 
 module Perennial
   
-  VERSION = "1.0.0.0"
+  VERSION = "1.0.0.1"
   
   has_library :dispatchable, :hookable, :loader, :logger, :nash,
               :loggable, :manifest, :settings, :argument_parser,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: Sutto-perennial
 version: !ruby/object:Gem::Version 
-  version: 1.0.0.0
+  version: 1.0.0.1
 platform: ruby
 authors: 
 - Darcy Laycock
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-17 00:00:00 -07:00
+date: 2009-09-19 00:00:00 -07:00
 default_executable: perennial
 dependencies: []
 
@@ -23,15 +23,6 @@ extra_rdoc_files: []
 
 files: 
 - bin/perennial
-- vendor/fakefs
-- vendor/fakefs/lib
-- vendor/fakefs/lib/fakefs.rb
-- vendor/fakefs/LICENSE
-- vendor/fakefs/Rakefile
-- vendor/fakefs/README.markdown
-- vendor/fakefs/test
-- vendor/fakefs/test/fakefs_test.rb
-- vendor/fakefs/test/verify.rb
 - lib/perennial
 - lib/perennial/application.rb
 - lib/perennial/argument_parser.rb
@@ -58,15 +49,6 @@ files:
 - lib/perennial/reloading.rb
 - lib/perennial/settings.rb
 - lib/perennial.rb
-- 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
 - templates/application.erb
 - templates/boot.erb
 - templates/rakefile.erb

data/test/delegateable_test.rb

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

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

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

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

data/test/loggable_test.rb

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

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