perennial 0.2.2.2

data/lib/perennial/settings.rb

@@ -0,0 +1,95 @@
+require 'yaml'
+
+module Perennial
+  class Settings
+    
+    cattr_accessor :configuration, :log_level, :verbose, :daemon
+                   
+    @@verbose   = false
+    @@log_level = :info
+    @@daemon    = false
+    
+    class << self
+      
+      def daemon?
+        !!@@daemon
+      end
+      
+      def verbose?
+        !!@@verbose
+      end
+      
+      def root=(path)
+        @@root = File.expand_path(path.to_str)
+      end
+      
+      def root
+        @@root ||= File.expand_path(File.dirname(__FILE__) / ".." / "..")
+      end
+      
+      def library_root=(path)
+        @@library_root = File.expand_path(path.to_str)
+      end
+      
+      def library_root
+        @@library_root ||= File.expand_path(File.dirname(__FILE__) / ".." / "..")
+      end
+      
+      def setup?
+        @@setup ||= false
+      end
+      
+      def setup(options = {})
+        self.setup!(options) unless setup?
+      end
+      
+      def setup!(options = {})
+        @@configuration = {}
+        settings_file = root / "config" / "settings.yml"
+        if File.exist?(settings_file)
+          loaded_yaml = YAML.load(File.read(settings_file))
+          @@configuration.merge! loaded_yaml["default"]
+        end
+        @@configuration.merge! options
+        @@configuration.symbolize_keys!
+        # Generate a module 
+        mod = generate_settings_accessor_mixin
+        extend  mod
+        include mod
+        @@setup = true
+      end
+      
+      def [](key)
+        self.setup
+        return self.configuration[key.to_sym]
+      end
+      
+      def []=(key, value)
+        self.setup
+        self.configuration[key.to_sym] = value
+        return value
+      end
+      
+      def to_hash
+        self.configuration.dup
+      end
+      
+      protected
+      
+      def generate_settings_accessor_mixin
+        Module.new do
+          Settings.configuration.keys.each do |k|
+            define_method(k) do
+              return Settings.configuration[k]
+            end
+            define_method("#{k}=") do |val|
+              Settings.configuration[k] = val
+            end
+          end
+        end
+      end
+      
+    end
+
+  end
+end

data/lib/perennial.rb

@@ -0,0 +1,21 @@
+# Append the perennial lib folder onto the load path to make it
+# nicer to require perennial-related libraries.
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'pathname'
+require 'perennial/core_ext'
+require 'perennial/exceptions'
+
+module Perennial
+  
+  VERSION = "0.2.2.2"
+  
+  has_libary :dispatchable, :hookable, :loader, :logger,
+             :loggable, :manifest, :settings, :argument_parser,
+             :option_parser, :application, :generator, :daemon
+  
+  def self.included(parent)
+    parent.extend(Manifest::Mixin)
+  end
+  
+end

data/templates/application.erb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'perennial'
+
+module <%= @application_module %>
+  include Perennial
+  
+  VERSION = "0.0.1"
+  
+  manifest do |m, l|
+    Settings.root = File.dirname(__FILE__)
+    # Initialize your controllers, e.g:
+    # l.register_controller :client, <%= @application_module %>::Client
+  end
+  
+end

data/templates/boot.erb

@@ -0,0 +1,2 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', <%= @application_path.to_s.inspect %>)
+<%= @application_module %>::Settings.root = Pathname.new(__FILE__).dirname.join("..").expand_path

data/templates/rakefile.erb

@@ -0,0 +1,31 @@
+require 'rake'
+require 'rake/testtask'
+
+task :default => "test:units"
+
+namespace :test do
+  
+  desc "Runs the unit tests for perennial"
+  Rake::TestTask.new("units") do |t|
+    t.pattern = 'test/*_test.rb'
+    t.libs << 'test'
+    t.verbose = true
+  end
+  
+end
+
+task :gemspec do
+  require 'rubygems'
+  require File.join(File.dirname(__FILE__), "lib", "<%= @application_path %>")
+  spec = Gem::Specification.new do |s|
+    s.name     = '<%= @application_path %>'
+    s.email    = ''
+    s.homepage = ''
+    s.authors  = ["YOUR NAME"]
+    s.version  = <%= @application_module %>::VERSION
+    s.summary  = ""
+    s.files    = FileList["{bin,vendor,lib,test}/**/*"].to_a
+    s.platform = Gem::Platform::RUBY
+  end
+  File.open("<%= @application_path %>.gemspec", "w+") { |f| f.puts spec.to_ruby }
+end

data/templates/setup.erb

@@ -0,0 +1,4 @@
+# Use this on a per-application setup / initialization basis.
+<%= @application_module %>::Loader.before_run do
+  # Do stuff here...
+end

data/templates/test.erb

@@ -0,0 +1,9 @@
+require 'test_helper'
+
+class <%= @application_module %>Test < Test::Unit::TestCase
+
+  should 'have tests' do
+    fail "You need to write some tests"
+  end
+
+end

data/templates/test_helper.erb

@@ -0,0 +1,35 @@
+require 'rubygems'
+
+# Testing dependencies
+require 'test/unit'
+require 'shoulda'
+# 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", "<%= @application_path %>")
+
+class Test::Unit::TestCase
+
+  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/test/dispatchable_test.rb

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

@@ -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,57 @@
+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

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

@@ -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

data/vendor/fakefs/LICENSE

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