Sutto-perennial 0.1.0

data/lib/perennial/loader.rb

@@ -0,0 +1,97 @@
+require 'singleton'
+
+module Perennial
+  class Loader
+    include Singleton
+    include Perennial::Hookable
+    
+    cattr_accessor :controllers, :current_type, :default_type
+    @@controllers = []
+    
+    define_hook :before_run, :after_stop
+    
+    def self.register_controller(name, controller)
+      return if name.blank? || controller.blank?
+      name = name.to_sym
+      @@controller[name] = controller
+      metaclass.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        def #{name}?                 # def client?
+          @@current_type == :#{name} #   @@current_type == :client
+        end                          # end
+      RUBY
+    end
+    
+    def self.run!(type = self.default_type)
+      @@current_type = type.to_sym
+      self.instance.run!
+    end
+    
+    def self.stop!(force = false)
+      self.instance.stop!(force)
+    end
+    
+    def run!
+      self.register_signals
+      OptionParser.setup
+      self.class.invoke_hooks! :before_setup
+      Daemon.daemonize! if Settings.daemon?
+      Logger.log_name = "#{@@current_type.to_s}.log"
+      Logger.setup
+      Settings.setup
+      self.load_custom_code
+      self.class.invoke_hooks!        :before_run
+      self.attempt_controller_action! :run
+    end
+    
+    def stop!(force = false)
+      if force || !@attempted_stop
+        self.class.invoke_hooks!        :before_stop
+        self.attempt_controller_action! :stop
+        self.class.invoke_hooks!        :after_stop
+        @attempted_stop = true
+      end
+      Daemon.cleanup! if Settings.daemon?
+    end
+    
+    def current_controller
+      @current_controller ||= @@controllers[@@current_type.to_sym]
+    end
+    
+    protected
+    
+    def load_custom_code
+      # Attempt to load a setup file given it exists.
+      begin
+        config_dir = Settings.root / "config"
+        setup_file = config_dir / "setup.rb"
+        require(setup_file) if File.directory?(handler_directory) && File.exist?(setup_file)
+      rescue LoadError
+      end
+      # Load any existing handlers assuming we can find the folder
+      handler_directory = Settings.root / "handlers"
+      if File.directory?(handler_directory)
+        Dir[handler_directory / "**" / "*.rb"].each do |handler|
+          require handler
+        end
+      end
+    end
+    
+    def register_signals
+      loader = self.class
+      %w(INT TERM).each do |signal|
+        trap(signal) do
+          loader.stop!
+          exit
+        end
+      end
+    end
+    
+    def attempt_controller_action!(action)
+      action = action.to_sym
+      unless current_controller.blank? || !current_controller.respond_to?(action)
+        current_controller.send(action)
+      end
+    end
+    
+  end
+end

data/lib/perennial/loggable.rb

@@ -0,0 +1,15 @@
+module Perennial
+  # A mixin that provides logger instance and
+  # class methods
+  module Loggable
+   
+    def self.included(parent)
+      parent.extend self
+    end
+    
+    def logger
+      Logger
+    end
+    
+  end
+end

data/lib/perennial/logger.rb

@@ -0,0 +1,106 @@
+module Perennial
+  class Logger
+    
+    cattr_accessor :logger, :log_name
+    
+    @@log_name = "perennial.log"
+    @@setup    = false
+    
+    class << self
+      
+      def setup?
+        !!@@setup
+      end
+      
+      def setup
+        return if setup?
+        setup!
+      end
+      
+      def setup!
+        log_path = Settings.root / "log" / @@log_name.to_str
+        @@logger = new(log_path, Settings.log_level, Settings.verbose?)
+        @@setup = true
+      end
+      
+      def method_missing(name, *args, &blk)
+       self.setup # Ensure the logger is setup
+       @@logger.send(name, *args, &blk)
+      end
+      
+      def respond_to?(symbol, include_private = false)
+        self.setup
+        super(symbol, include_private) || @@logger.respond_to?(symbol, include_private)
+      end
+    
+    end
+    
+    LEVELS = {
+      :fatal => 7,
+      :error => 6,
+      :warn  => 4,
+      :info  => 3,
+      :debug => 0
+    }
+  
+    PREFIXES = {}
+  
+    LEVELS.each { |k,v| PREFIXES[k] = "[#{k.to_s.upcase}]".ljust 7 }
+
+    COLOURS = {
+      :fatal => 31, # red
+      :error => 33, # yellow
+      :warn  => 35, # magenta
+      :info  => 32, # green
+      :debug => 34  # white
+    }
+  
+    attr_accessor :level, :file, :verbose
+  
+    def initialize(path, level = :info, verbose = false)
+      @level   = level.to_sym
+      @verbose = verbose
+      @file    = File.open(path, "a+")
+    end
+  
+    def close!
+      @file.close
+    end
+  
+    LEVELS.each do |name, value|
+      define_method(name) do |message|
+        write("#{PREFIXES[name]} #{message}", name) if LEVELS[@level] <= value
+      end
+    
+      define_method(:"#{name}?") do
+        LEVELS[@level] <= value
+      end
+      
+    end
+  
+    def log_exception(exception)
+      error "Exception: #{exception}"
+      exception.backtrace.each do |l|
+        error ">> #{l}"
+      end
+    end
+    
+    def verbose?
+      !!@vebose
+    end
+  
+    private
+  
+    def write(message, level = self.level)
+      @file.puts message
+      @file.flush
+      $stdout.puts colourize(message, level) if verbose?
+    end
+  
+    def colourize(message, level)
+      "\033[1;#{COLOURS[level]}m#{message}\033[0m"
+    end
+ 
+    
+  end
+end

data/lib/perennial/manifest.rb

@@ -0,0 +1,32 @@
+module Perennial
+  class Manifest
+    
+    class_inheritable_accessor :app_name, :namespace
+    self.app_name  = :perennial
+    self.namespace =  Perennial
+    
+    def self.inspect
+      "#<#{self.name} app_name: #{self.app_name.inspect}, namespace: #{self.namespace.inspect}>"
+    end
+    
+    module Mixin
+      # Called in your application to set the default
+      # namespace and app_name. Also, if a block is
+      # provided it yields first with Manifest and then
+      # with the Loader class, making it simpler to setup.
+      def manifest(&blk)
+        Manifest.namespace = self
+        Manifest.app_name  = self.name.to_s.underscore
+        parent_folder = __DIR__(1)
+        attempt_require parent_folder / 'core_ext', parent_folder / 'exceptions'
+        unless blk.nil?
+          args = []
+          args << Manifest if blk.arity != 0
+          args << Loader   if blk.arity > 1 || blk.arity < 0
+          blk.call(*args)
+        end
+      end
+    end
+    
+  end
+end

data/lib/perennial/option_parser.rb

@@ -0,0 +1,108 @@
+require 'singleton'
+module Perennial
+  class OptionParser
+    include Singleton
+    
+    attr_reader :arguments
+    
+    def initialize
+      @parsed_values = {}
+      @arguments     = []
+      @callbacks     = {}
+      @descriptions  = {}
+      @shortcuts     = {}
+    end
+    
+    def add(name, description, opts = {}, &blk)
+      name = name.to_sym
+      @callbacks[name] = blk
+      @descriptions[name] = description
+      shortcut = opts.has_key?(:shortcut) ? opts[:shortcut] : generate_default_shortcut(name)
+      @shortcuts[shortcut] = name unless shortcut.blank?
+    end
+    
+    def summary
+      output = []
+      max_length = 0
+      @callbacks.each_key do |name|
+        shortcuts = []
+        @shortcuts.each_pair { |k,v| shortcuts << k if v == name }
+        text = "--#{name.to_s.gsub("_", "-")}"
+        text << ", #{shortcuts.map { |sc| "-#{sc}" }.join(", ")}" unless shortcuts.empty?
+        max_length = [text.size, max_length].max
+        output << [text, @descriptions[name]]
+      end
+      output.map { |text, description| "#{text}: ".ljust(max_length + 2) + description }.join("\n")
+    end
+    
+    def parse(arguments = ARGV)
+      arguments, options = ArgumentParser.parse(arguments)
+      @arguments = arguments
+      options.each_pair do |name, value|
+        name = name.gsub("-", "_")
+        expanded_name = @shortcuts[name] || name.to_sym
+        callback = @callbacks[expanded_name]
+        callback.call(value) if callback.present?
+      end
+      return nil
+    end
+    
+    def self.method_missing(name, *args, &blk)
+      self.instance.send(name, *args, &blk)
+    end
+    
+    # Over ride with your apps custom banner
+    def self.print_banner
+    end
+    
+    def add_defaults!
+      return if defined?(@defaults_added) && @defaults_added
+      logger_levels = Logger::LEVELS.keys.map { |k| k.to_s }
+      add(:daemon, 'Runs this application as a daemon') { Settings.daemon = true }
+      add(:verbose, 'Runs this application verbosely, writing to STDOUT') { Settings.verbose = true }
+      add(:log_level, "Sets this applications log level, one of: #{logger_levels.join(", ")}") do |level|
+        if logger_levels.include?(level)
+          Settings.log_level = level.to_sym
+        else
+          puts "The provided log level must be one of #{logger_levels.join(", ")} (Given #{level})"
+          exit!
+        end
+      end
+      add(:help, "Shows this help message") do
+        self.print_banner
+        $stdout.puts "Usage: #{$0} [options]"
+        $stdout.puts "\nOptions:"
+        $stdout.puts self.summary
+        exit!
+      end
+      @defaults_added = true
+    end
+    
+    def setup
+      return if defined?(@setup) && @setup
+      setup!
+      @setup = true
+    end
+    
+    def self.setup!
+      opts = self.instance
+      opts.add_defaults!
+      opts.parse
+      ARGV.replace opts.arguments
+    end
+    
+    protected
+    
+    def generate_default_shortcut(name)
+      raw = name.to_s[0, 1]
+      if !@shortcuts.has_key?(raw)
+        return raw
+      elsif !@shortcuts.has_key?(raw.upcase)
+        return raw.upcase
+      else
+        raise "No shortcut option could generate for '#{name}' - Please specify :short (possibly as nil) to override"
+      end
+    end
+    
+  end
+end

data/lib/perennial/settings.rb

@@ -0,0 +1,87 @@
+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 = path.to_str
+      end
+      
+      def root
+        @@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.1.0"
+  
+  has_libary :dispatchable, :hookable, :loader, :logger,
+             :loggable, :manifest, :settings, :argument_parser,
+             :option_parser
+  
+  def self.included(parent)
+    parent.extend(Manifest::Mixin)
+  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