perennial 0.2.2.2 → 1.0.0.1

data/bin/perennial

@@ -15,8 +15,7 @@ Perennial::Application.processing(ARGV) do |a|
     path     = File.expand_path(path)
     # Check if the folder exists
     if File.exist?(path) && !opts[:force]
-      puts "The path you tried to use, #{path}, already exists. Please try another or pass --force"
-      exit
+      die! "The path you tried to use, #{path}, already exists. Please try another or pass --force"
     end
     # Convert the name and class name.
     app_path   = app_name.underscore

data/lib/perennial/application.rb

@@ -15,6 +15,29 @@ module Perennial
         klass.new.apply(*arguments)
       end
       
+      def yes?(question)
+        result = Readline.readline("#{question.to_s.strip} (y/n) ")
+        result.downcase[0] == ?y
+      end
+      
+      def ask(question, default)
+        result = Readline.readline("#{question.to_s.strip} (default: #{default}) ")
+        result.blank? ? default : result
+      end
+      
+      def ask_password(question)
+        system "stty -echo" 
+        line = Readline.readline("#{question.to_s.strip} ").strip
+        system "stty echo"
+        print "\n"
+        return line
+      end
+      
+      def die!(message)
+        $stderr.puts message
+        exit! 1
+      end
+      
     end
     
     attr_accessor :options, :banner, :command_env
@@ -30,8 +53,8 @@ module Perennial
       @banners         = {}
     end
     
-    def option(name, description = nil)
-      option_parser.add(name, description) { |v| @command_options[name] = v }
+    def option(name, description = nil, opts = {})
+      option_parser.add(name, description, opts) { |v| @command_options[name] = v }
     end
     
     def add_default_options!
@@ -44,19 +67,21 @@ module Perennial
       end
     end
     
-    def controller!(controller, description)
+    def controller!(controller, description, opts = {})
       return unless defined?(Loader)
       add_default_options!
       option :kill, "Kill any runninng instances"
       controller_name = controller.to_s.underscore
       controller = controller.to_sym
       command_name = controller_name.gsub("_", "-")
-      add("#{command_name} [PATH]", description) do |*args|
+      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)
-          puts "Attempting to kill processess..."
+          parent.attempt_showing_banner
+          puts "Attempting to kill processess for #{command_name}"
           Daemon.kill_all(controller)
         else
           Loader.run!(controller, options)
@@ -86,35 +111,32 @@ module Perennial
       if @commands.has_key?(command)
         execute_command(command, arguments)
       else
-        puts "Unknown command '#{command}', please try again."
-        return usage
+        show_error "Unknown command '#{command}', please try again."
+        usage(true)
       end
     end
     
-    def usage
-      if banner.present?
-        puts banner
-        puts ""
-      end
+    def usage(skip_banner = false)
+      attempt_showing_banner unless skip_banner
       puts "Usage:"
       max_width = @banners.values.map { |b| b.length }.max
       @commands.keys.sort.each do |command|
         next unless @descriptions.has_key?(command)
         formatted_command = "#{@banners[command]} [OPTIONS]".ljust(max_width + 10)
-        command = "%s - %s" % [formatted_command, @descriptions[command]]
+        command = "  %s - %s" % [formatted_command, @descriptions[command]]
         puts command
       end
+      puts ""
+      puts "Please note: you can pass -h / --help to any command for more specific help"
     end
     
-    def help_for(command)
-     if banner.present?
-        puts banner
-        puts ""
-      end
+    def help_for(command, skip_banner = false)
+      attempt_showing_banner unless skip_banner
       puts @descriptions[command]
+      puts ""
       puts "Usage: #{$0} #{@banners[command]} [options]"
       puts "Options:"
-      puts @option_parsers[command].summary
+      puts pad_left(@option_parsers[command].summary)
       exit
     end
     
@@ -127,6 +149,13 @@ module Perennial
       end
       application.execute args
     end
+  
+    def attempt_showing_banner
+      if banner.present?
+        puts banner
+        puts ""
+      end
+    end
     
     protected
     
@@ -137,7 +166,7 @@ module Perennial
         args << opts
         @command_env.execute(command_proc, args)
       else
-        usage
+        help_for(command, true)
       end
     end
     
@@ -160,14 +189,28 @@ module Perennial
       needed_count   = blk.arity - 1
       provided_count = arguments.size
       if needed_count > 0 && needed_count != provided_count
-        puts "You didn't provide the correct number of arguments (needed #{needed_count}, provided #{provided_count})"
+        attempt_showing_banner
+        show_error "You didn't provide the correct number of arguments (needed #{needed_count}, provided #{provided_count})"
       elsif needed_count < 0 && (-needed_count - 2) > provided_count
-        puts "You didn't provide enough arguments - a minimum of #{-needed_count} are needed."
+        show_error "You didn't provide enough arguments - a minimum of #{-needed_count} are needed."
       else
         return true
       end
       
     end
     
+    def show_error(text)
+      attempt_showing_banner
+      text = "Error: #{text}".strip
+      puts "--#{"-" * text.length}"
+      puts " #{text} "
+      puts "--#{"-" * text.length}"
+      puts ""
+    end
+    
+    def pad_left(text, spacing = 2)
+      text.split("\n").map { |l| "#{" " * spacing}#{l}" }.join("\n")
+    end
+    
   end
 end

data/lib/perennial/core_ext/attribute_accessors.rb

@@ -1,6 +1,31 @@
 # cattr_* and class_inheritable_* are taken from
 # ActiveSupport. Included here to help keep the
 # codebase simple / clean.
+
+class Object
+  
+  unless respond_to?(:instance_variable_defined?)
+    def instance_variable_defined?(variable)
+      instance_variables.include?(variable.to_s)
+    end
+  end
+
+  def instance_values #:nodoc:
+    instance_variables.inject({}) do |values, name|
+      values[name.to_s[1..-1]] = instance_variable_get(name)
+      values
+    end
+  end
+
+  if RUBY_VERSION >= '1.9'
+    def instance_variable_names
+      instance_variables.map { |var| var.to_s }
+    end
+  else
+    alias_method :instance_variable_names, :instance_variables
+  end
+end
+
 class Class
   def cattr_reader(*syms)
     syms.flatten.each do |sym|

data/lib/perennial/core_ext/hash_key_conversions.rb

@@ -0,0 +1,26 @@
+class Hash
+  def symbolize_keys
+    hash = self.dup
+    hash.symbolize_keys!
+    return hash
+  end
+  
+  def symbolize_keys!
+    hash = {}
+    self.each_pair { |k,v| hash[k.to_sym] = v }
+    replace hash
+  end
+  
+  def stringify_keys!
+    hash = {}
+    self.each_pair { |k, v| hash[k.to_s] = v }
+    replace hash
+  end
+  
+  def stringify_keys
+    hash = self.dup
+    hash.stringify_keys!
+    return hash
+  end
+  
+end

data/lib/perennial/core_ext/inflections.rb

@@ -0,0 +1,33 @@
+module Perennial
+  class Inflector
+    class << self
+
+      def underscore(camel_cased_word)
+        camel_cased_word.to_s.gsub(/::/, '/').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          tr("-", "_").
+          downcase
+      end
+    
+      def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+        if first_letter_in_uppercase
+          lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+        else
+          lower_case_and_underscored_word.first.downcase + camelize(lower_case_and_underscored_word)[1..-1]
+        end
+      end
+    
+    end
+  end
+end
+
+class String
+  def underscore
+    Perennial::Inflector.underscore(self)
+  end
+  
+  def camelize(capitalize_first_letter = true)
+    Perennial::Inflector.camelize(self, capitalize_first_letter)
+  end
+end

data/lib/perennial/core_ext/misc.rb

@@ -3,30 +3,14 @@ class Object
   def metaclass
     class << self; self; end
   end
+  
+  def meta_def(name, &blk)
+    metaclass.define_method(name, &blk)
+  end
 
 end
 
-class Inflector
-  class << self
 
-    def underscore(camel_cased_word)
-      camel_cased_word.to_s.gsub(/::/, '/').
-        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-        gsub(/([a-z\d])([A-Z])/,'\1_\2').
-        tr("-", "_").
-        downcase
-    end
-    
-    def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
-      if first_letter_in_uppercase
-        lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
-      else
-        lower_case_and_underscored_word.first.downcase + camelize(lower_case_and_underscored_word)[1..-1]
-      end
-    end
-    
-  end
-end
 
 module Kernel
   
@@ -53,14 +37,6 @@ class String
     File.join(self, *args)
   end
   
-  def underscore
-    Inflector.underscore(self)
-  end
-  
-  def camelize(capitalize_first_letter = true)
-    Inflector.camelize(self, capitalize_first_letter)
-  end
-  
   def to_pathname
     Pathname.new(self)
   end
@@ -72,23 +48,9 @@ class Array
   end
 end
 
-class Hash
-  def symbolize_keys
-    hash = self.dup
-    hash.symbolize_keys!
-    return hash
-  end
-  
-  def symbolize_keys!
-    hash = {}
-    self.each_pair { |k,v| hash[k.to_sym] = v }
-    replace hash
-  end
-end
-
 class Module
   
-  def has_libary(*items)
+  def has_library(*items)
     namespace = self.to_s.underscore
     items.each do |item|
       require File.join(namespace, item.to_s.underscore)
@@ -106,6 +68,19 @@ class Module
     end 
   end
   
+  def add_extension(name, &blk)
+    item = name.to_s.camelize.to_sym
+    target = const_get(item) rescue nil
+    raise "Didn't find library for #{name}" if target.nil?
+    if target.is_a?(Class)
+      target.class_eval(&blk)
+    elsif target.is_a?(Module)
+      target.module_eval(&blk)
+    else
+      raise "Unable to extend #{target.inspect}"
+    end
+  end
+  
   def attempt_require(*files)
     files.each do |file|
       begin
@@ -115,4 +90,19 @@ class Module
     end
   end
   
+end
+
+class Class
+  
+  def is(*mixins)
+    ns = Perennial::Manifest.namespace
+    return if ns.blank?
+    mixins.each do |mixin|
+      begin
+        include ns.const_get(mixin.to_s.camelize)
+      rescue NameError
+      end
+    end
+  end
+  
 end

data/lib/perennial/core_ext/proxy.rb

@@ -0,0 +1,16 @@
+module Perennial
+  # a super simple proxy class.
+  class Proxy
+    
+    instance_methods.each { |m| undef_method m unless m =~ /(^__|^send$|^object_id$)/ }
+    
+    attr_accessor :__proxy_target__
+    
+    protected
+    
+    def method_missing(m, *args, &blk)
+      __proxy_target__.send(m, *args, &blk)
+    end
+    
+  end
+end

data/lib/perennial/core_ext.rb

@@ -1,4 +1,7 @@
 # Require each individial core extension
 require 'perennial/core_ext/attribute_accessors'
 require 'perennial/core_ext/blank'
-require 'perennial/core_ext/misc'
+require 'perennial/core_ext/misc'
+require 'perennial/core_ext/hash_key_conversions'
+require 'perennial/core_ext/inflections'
+require 'perennial/core_ext/proxy'

data/lib/perennial/daemon.rb

@@ -62,9 +62,9 @@ module Perennial
       # the double fork approach. Also, changes process file
       # mask to 000 and reopens STDIN / OUT to /dev/null
       def daemonize!
-        exit if fork
+        fork_off_and_die
         Process.setsid
-        exit if fork
+        fork_off_and_die
         self.write_pid
         File.umask    0000
         STDIN.reopen  "/dev/null"
@@ -118,6 +118,13 @@ module Perennial
         File.open(f, "w+") { |f| f.puts pids.join("\n") }
       end
       
+      def fork_off_and_die
+        if pid = fork
+          Process.detach(pid)
+          exit
+        end
+      end
+      
     end
   end
 end

data/lib/perennial/delegateable.rb

@@ -0,0 +1,48 @@
+module Perennial
+  # Objective-C / Cocoa style 'delegates'.
+  # Essentially proxies which dispatch only
+  # when an object responds to the method.
+  class DelegateProxy < Proxy
+    
+    def initialize(t)
+      @__proxy_target__ = t
+    end
+    
+    def respond_to?(method, inc_super = false)
+      true
+    end
+    
+    protected
+    
+    def method_missing(method, *args, &blk)
+      @__proxy_target__.send(method, *args, &blk) if @__proxy_target__.respond_to?(method)
+    end
+    
+  end
+  
+  module Delegateable
+    
+    def self.included(parent)
+      parent.send(:include, InstanceMethods)
+    end
+    
+    module InstanceMethods
+      
+      def delegate=(value)
+        @delegate = DelegateProxy.new(value)
+      end
+      
+      alias delegate_to delegate=
+      
+      def delegate
+        @delegate ||= DelegateProxy.new(nil)
+      end
+      
+      def real_delegate
+        @delegate && @delegate.__proxy_target__
+      end
+      
+    end
+    
+  end
+end

data/lib/perennial/dispatchable.rb

@@ -21,6 +21,10 @@ module Perennial
       @@handler_mapping ||= Hash.new { |h,k| h[k] = [] }
     end
     
+    def self.reloading_mapping
+      @@reloading_mapping ||= Hash.new { |h,k| h[k] = [] }
+    end
+    
     def self.included(parent)
       parent.class_eval do
         include InstanceMethods
@@ -36,6 +40,14 @@ module Perennial
         self.class.handlers
       end
       
+      def dispatch_queue
+        @dispatch_queue ||= []
+      end
+      
+      def dispatching?
+        @dispatching ||= false
+      end
+      
       # Dispatch an 'event' with a given name to the handlers
       # registered on the current class. Used as a nicer way of defining
       # behaviours that should occur under a given set of circumstances.
@@ -43,32 +55,44 @@ module Perennial
       # +name+: The name of the current event
       # +opts+: an optional hash of options to pass
       def dispatch(name, opts = {})
-        # The full handler name is the method we call given it exists.
-        full_handler_name = :"handle_#{name.to_s.underscore}"
-        # First, dispatch locally if the method is defined.
-        self.send(full_handler_name, opts) if self.respond_to?(full_handler_name)
-        # Iterate through all of the registered handlers,
-        # If there is a method named handle_<event_name>
-        # defined we sent that otherwise we call the handle
-        # method on the handler. Note that the handle method
-        # is the only required aspect of a handler. An improved
-        # version of this would likely cache the respond_to?
-        # call.
-        self.handlers.each do |handler|
-          if handler.respond_to?(full_handler_name)
-            handler.send(full_handler_name, opts)
-          else
-            handler.handle name, opts
+        if !dispatching?
+          Logger.debug "Dispatching #{name} event (#{dispatch_queue.size} queued - on #{self.class.name})"
+          # Add ourselves to the queue
+          @dispatching = true
+          begin
+            # The full handler name is the method we call given it exists.
+            full_handler_name = :"handle_#{name.to_s.underscore}"
+            # First, dispatch locally if the method is defined.
+            self.send(full_handler_name, opts) if self.respond_to?(full_handler_name)
+            # Iterate through all of the registered handlers,
+            # If there is a method named handle_<event_name>
+            # defined we sent that otherwise we call the handle
+            # method on the handler. Note that the handle method
+            # is the only required aspect of a handler. An improved
+            # version of this would likely cache the respond_to?
+            # call.
+            self.handlers.each do |handler|
+              if handler.respond_to?(full_handler_name)
+                handler.send(full_handler_name, opts)
+              else
+                handler.handle name, opts
+              end
+            end
+          # If we get the HaltHandlerProcessing exception, we
+          # catch it and continue on our way. In essence, we
+          # stop the dispatch of events to the next set of the
+          # handlers.
+          rescue HaltHandlerProcessing => e
+            Logger.info "Halting processing chain"
+          rescue Exception => e
+            Logger.log_exception(e)
           end
+          @dispatching = false
+          dispatch(*@dispatch_queue.shift) unless dispatch_queue.empty?
+        else
+          Logger.debug "Adding #{name} event to the end of the queue (on #{self.class.name})"
+          dispatch_queue << [name, opts]
         end
-      # If we get the HaltHandlerProcessing exception, we
-      # catch it and continue on our way. In essence, we
-      # stop the dispatch of events to the next set of the
-      # handlers.
-      rescue HaltHandlerProcessing => e
-        Logger.info "Halting processing chain"
-      rescue Exception => e
-        Logger.log_exception(e)
       end
       
     end
@@ -100,10 +124,29 @@ module Perennial
       # Handlers are called in the order they are registered.
       def register_handler(handler)
         unless handler.blank? || !handler.respond_to?(:handle)
+          handler.registered = true if handler.respond_to?(:registered=)
           Dispatchable.handler_mapping[self] << handler 
         end
       end
       
+      def delete_handler(handler)
+        return if handler.blank?
+        handler.registered = false if handler.respond_to?(:registered=)
+        Dispatchable.handler_mapping[self].delete(handler)
+      end
+      
+      def reloading!
+        handlers = Dispatchable.handler_mapping.delete(self)
+        Dispatchable.reloading_mapping[self.name] = handlers
+      end
+      
+      def reloaded!
+        if Dispatchable.reloading_mapping.has_key?(self.name)
+          handlers = Dispatchable.reloading_mapping.delete(self.name)
+          handlers.each { |h| register_handler(h) }
+        end
+      end
+      
     end
     
   end