perennial 0.2.2.2 → 1.0.0.1

data/test/dispatchable_test.rb

@@ -1,129 +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
-  
-  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
-  
-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,57 +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
-    
-    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/settings_test.rb

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

data/test/test_helper.rb

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

data/vendor/fakefs/LICENSE

@@ -1,20 +0,0 @@
-Copyright (c) 2009 Chris Wanstrath
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/fakefs/README.markdown

@@ -1,37 +0,0 @@
-FakeFS
-======
-
-Mocha is great. But when your library is all about manipulating the
-filesystem, you really want to test the behavior and not the implementation.
-
-If you're mocking and stubbing every call to FileUtils or File, you're 
-tightly coupling your tests with the implementation.
-
-    def test_creates_directory
-      FileUtils.expects(:mkdir).with("directory").once
-      Library.add "directory"
-    end
-
-The above test will break if we decide to use `mkdir_p` in our code. Refactoring
-code shouldn't necessitate refactoring tests.
-
-With FakeFS:
-
-    def test_creates_directory
-      Library.add "directory"
-      assert File.directory?("directory")
-    end
-
-Woot.
-
-How is this different than MockFS?
-----------------------------------
-
-FakeFS provides a test suite and works with symlinks. It's also strictly a 
-test-time dependency: your actual library does not need to use or know about
-FakeFS.
-
-Authors
--------
-
-Chris Wanstrath [chris@ozmm.org]

data/vendor/fakefs/Rakefile

@@ -1,3 +0,0 @@
-task :default do
-  exec "ruby test/fakefs_test.rb"
-end