perennial 0.2.2.2

data/bin/perennial

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+require File.join(File.dirname(__FILE__), "..", "lib", "perennial")
+
+Perennial::Application.processing(ARGV) do |a|
+  
+  a.banner = "Perennial v#{Perennial::VERSION} CLI"
+  
+  a.generator!
+  
+  a.option(:force, "force the creation of the application")
+  a.add("create PATH [APP-NAME]", "Creates a Perennial-based library with a given PATH and, if provided, APP-NAME.") do |path, *args|
+    # Get the app name, path etc.
+    opts     = args.extract_options!
+    app_name = args.empty? ? File.basename(path) : args.shift
+    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
+    end
+    # Convert the name and class name.
+    app_path   = app_name.underscore
+    app_module = app_name.camelize
+    # Actually do the generation.
+    env = {:application_module => app_module, :application_path => app_path}
+    setup_generator path
+    folders  'tmp', 'config', 'lib', 'handlers', 'test'
+    template 'application.erb', "lib/#{app_path}.rb",       env
+    template 'boot.erb',        'config/boot.rb',           env
+    template 'setup.erb',       'config/setup.rb',          env
+    template 'rakefile.erb',    'Rakefile',                 env
+    template 'test_helper.erb', 'test/test_helper.rb',      env
+    template 'test.erb',        "test/#{app_path}_test.rb", env
+  end
+  
+end

data/lib/perennial/application.rb

@@ -0,0 +1,173 @@
+module Perennial
+  class Application
+    
+    class CommandEnv
+      include Loggable
+      
+      # Executes a given block with given
+      # arguments in a specified environment.
+      # Used to provide the logger functionality
+      # as well as the ability to do things
+      # such as easily write generators.
+      def self.execute(blk, arguments)
+        klass = Class.new(self)
+        klass.class_eval { define_method(:apply, &blk) }
+        klass.new.apply(*arguments)
+      end
+      
+    end
+    
+    attr_accessor :options, :banner, :command_env
+    
+    def initialize(opts = {})
+      @options         = opts
+      @commands        = {}
+      @descriptions    = {}
+      @option_parsers  = {}
+      @option_parser   = nil
+      @command_options = {}
+      @command_env     = (opts[:command_env] || CommandEnv)
+      @banners         = {}
+    end
+    
+    def option(name, description = nil)
+      option_parser.add(name, description) { |v| @command_options[name] = v }
+    end
+    
+    def add_default_options!
+      option_parser.add_defaults!
+    end
+    
+    def generator!
+      if defined?(Generator)
+        self.command_env = Generator::CommandEnv
+      end
+    end
+    
+    def controller!(controller, description)
+      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|
+        options = args.extract_options!
+        path = File.expand_path(args[0] || ".")
+        Settings.root = path
+        if options.delete(:kill)
+          puts "Attempting to kill processess..."
+          Daemon.kill_all(controller)
+        else
+          Loader.run!(controller, options)
+        end
+      end
+    end
+    
+    
+    
+    def add(raw_command, description = nil, &blk)
+      raise ArgumentError, "You must provide a block with an #{self.class.name}#add" if blk.nil?
+      raise ArgumentError, "Your block must accept atleast one argument (a hash of options)" if blk.arity == 0
+      command, _ = raw_command.split(" ", 2)
+      @banners[command] = raw_command
+      @commands[command]     = blk
+      @descriptions[command] = description if description.present?
+      # Add the default help message for a command
+      option_parser.add(:help, "Show this message") { help_for(command) }
+      @option_parsers[command] = option_parser
+      @option_parser = nil
+    end
+    
+    def execute(arguments)
+      return usage if arguments.empty?
+      arguments = arguments.dup
+      command = arguments.shift
+      if @commands.has_key?(command)
+        execute_command(command, arguments)
+      else
+        puts "Unknown command '#{command}', please try again."
+        return usage
+      end
+    end
+    
+    def usage
+      if banner.present?
+        puts banner
+        puts ""
+      end
+      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]]
+        puts command
+      end
+    end
+    
+    def help_for(command)
+     if banner.present?
+        puts banner
+        puts ""
+      end
+      puts @descriptions[command]
+      puts "Usage: #{$0} #{@banners[command]} [options]"
+      puts "Options:"
+      puts @option_parsers[command].summary
+      exit
+    end
+    
+    def self.processing(args, &blk)
+      application = self.new
+      if blk.arity == 1
+        blk.call(application)
+      else
+        application.instance_eval(&blk)
+      end
+      application.execute args
+    end
+    
+    protected
+    
+    def execute_command(command, arguments)
+      command_proc = @commands[command]
+      args, opts = extract_arguments(command, arguments)
+      if valid_arity?(command_proc, args)
+        args << opts
+        @command_env.execute(command_proc, args)
+      else
+        usage
+      end
+    end
+    
+    def extract_arguments(command, arguments)
+      option_parser = @option_parsers[command]
+      if option_parser.present?
+        option_parser.parse(arguments)
+        return option_parser.arguments, @command_options
+      else
+        return arguments, {}
+      end
+    end
+    
+    def option_parser(reset = false)
+      @option_parser = nil if reset
+      @option_parser ||= OptionParser.new
+    end
+    
+    def valid_arity?(blk, arguments)
+      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})"
+      elsif needed_count < 0 && (-needed_count - 2) > provided_count
+        puts "You didn't provide enough arguments - a minimum of #{-needed_count} are needed."
+      else
+        return true
+      end
+      
+    end
+    
+  end
+end

data/lib/perennial/argument_parser.rb

@@ -0,0 +1,60 @@
+require 'shellwords'
+
+module Perennial
+  class ArgumentParser
+    
+    attr_reader :arguments
+    
+    def initialize(array)
+      @raw_arguments = array.dup
+      @arguments     = []
+      @results       = {}
+    end
+    
+    def to_hash
+      @results ||= {}
+    end
+    
+    def parse!
+      while !@raw_arguments.empty?
+        current = @raw_arguments.shift
+        if option?(current)
+          process_option(current, @raw_arguments.first) 
+        else
+          @arguments.push current
+        end
+      end
+      return nil
+    end
+    
+    def self.parse(args = ARGV)
+      parser = self.new(args)
+      parser.parse!
+      return parser.arguments, parser.to_hash
+    end
+    
+    protected
+    
+    def process_option(current, next_arg)
+      name = clean(current)
+      if name.include?("=")
+        real_name, raw_value = name.split("=", 2)
+        @results[real_name] = Shellwords.shellwords(raw_value).join(" ")
+      elsif !(next_arg.nil? || option?(next_arg))
+        @raw_arguments.shift
+        @results[name] = next_arg
+      else
+        @results[name] = true
+      end
+    end
+    
+    def clean(name)
+      name.gsub /^\-+/, ''
+    end
+    
+    def option?(argument)
+      argument.strip =~ /^\-+/
+    end
+    
+  end
+end

data/lib/perennial/core_ext/attribute_accessors.rb

@@ -0,0 +1,129 @@
+# cattr_* and class_inheritable_* are taken from
+# ActiveSupport. Included here to help keep the
+# codebase simple / clean.
+class Class
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}  # unless defined? @@hair_colors
+          @@#{sym} = nil          #   @@hair_colors = nil
+        end                       # end
+                                  #
+        def self.#{sym}           # def self.hair_colors
+          @@#{sym}                #   @@hair_colors
+        end                       # end
+                                  #
+        def #{sym}                # def hair_colors
+          @@#{sym}                #   @@hair_colors
+        end                       # end
+      EOS
+    end
+  end
+ 
+  def cattr_writer(*syms)
+    options = syms.extract_options!
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}                       # unless defined? @@hair_colors
+          @@#{sym} = nil                               #   @@hair_colors = nil
+        end                                            # end
+                                                       #
+        def self.#{sym}=(obj)                          # def self.hair_colors=(obj)
+          @@#{sym} = obj                               #   @@hair_colors = obj
+        end                                            # end
+                                                       #
+        #{"                                            #
+        def #{sym}=(obj)                               # def hair_colors=(obj)
+          @@#{sym} = obj                               #   @@hair_colors = obj
+        end                                            # end
+        " unless options[:instance_writer] == false }  # # instance writer above is generated unless options[:instance_writer] == false
+      EOS
+    end
+  end
+ 
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+  
+  # Defines class-level inheritable attribute reader. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[#to_s]> Array of attributes to define inheritable reader for.
+  # @return <Array[#to_s]> Array of attributes converted into inheritable_readers.
+  #
+  # @api public
+  #
+  # @todo Do we want to block instance_reader via :instance_reader => false
+  # @todo It would be preferable that we do something with a Hash passed in
+  #   (error out or do the same as other methods above) instead of silently
+  #   moving on). In particular, this makes the return value of this function
+  #   less useful.
+  def class_inheritable_reader(*ivars)
+    instance_reader = ivars.pop[:reader] if ivars.last.is_a?(Hash)
+ 
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}
+          return @#{ivar} if self.object_id == #{self.object_id} || defined?(@#{ivar})
+          ivar = superclass.#{ivar}
+          return nil if ivar.nil? && !#{self}.instance_variable_defined?("@#{ivar}")
+          @#{ivar} = ivar && !ivar.is_a?(Module) && !ivar.is_a?(Numeric) && !ivar.is_a?(TrueClass) && !ivar.is_a?(FalseClass) ? ivar.dup : ivar
+        end
+      RUBY
+      unless instance_reader == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}
+            self.class.#{ivar}
+          end
+        RUBY
+      end
+    end
+  end
+ 
+  # Defines class-level inheritable attribute writer. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
+  #   define inheritable writer for.
+  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
+  # @return <Array[#to_s]> An Array of the attributes that were made into inheritable writers.
+  #
+  # @api public
+  #
+  # @todo We need a style for class_eval <<-HEREDOC. I'd like to make it
+  #   class_eval(<<-RUBY, __FILE__, __LINE__), but we should codify it somewhere.
+  def class_inheritable_writer(*ivars)
+    instance_writer = ivars.pop[:writer] if ivars.last.is_a?(Hash)
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}=(obj)
+          @#{ivar} = obj
+        end
+      RUBY
+      unless instance_writer == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}=(obj) self.class.#{ivar} = obj end
+        RUBY
+      end
+ 
+      self.send("#{ivar}=", yield) if block_given?
+    end
+  end
+ 
+  # Defines class-level inheritable attribute accessor. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
+  #   define inheritable accessor for.
+  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
+  # @return <Array[#to_s]> An Array of attributes turned into inheritable accessors.
+  #
+  # @api public
+  def class_inheritable_accessor(*syms, &block)
+    class_inheritable_reader(*syms)
+    class_inheritable_writer(*syms, &block)
+  end
+  
+end

data/lib/perennial/core_ext/blank.rb

@@ -0,0 +1,51 @@
+# blank? parts taken from the active support source
+# code, used under the MIT License.
+
+class Object
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+
+  def present?
+    !blank?
+  end
+
+end
+ 
+class NilClass #:nodoc:
+  def blank?
+    true
+  end
+end
+ 
+class FalseClass #:nodoc:
+  def blank?
+    true
+  end
+end
+ 
+class TrueClass #:nodoc:
+  def blank?
+    false
+  end
+end
+ 
+class Array #:nodoc:
+  alias_method :blank?, :empty?
+end
+ 
+class Hash #:nodoc:
+  alias_method :blank?, :empty?
+end
+ 
+class String #:nodoc:
+  def blank?
+    self !~ /\S/
+  end
+end
+ 
+class Numeric #:nodoc:
+  def blank?
+    false
+  end
+end

data/lib/perennial/core_ext/misc.rb

@@ -0,0 +1,118 @@
+class Object
+
+  def metaclass
+    class << self; self; end
+  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
+  
+  # From http://oldrcrs.rubypal.com/rcr/show/309
+  def __DIR__(offset = 0)
+    (/^(.+)?:\d+/ =~ caller[offset + 1]) ? File.dirname($1) : nil
+  end
+  
+  # Shorthand for lambda
+  # e.g. L{|r| puts r}
+  def L(&blk)
+    lambda(&blk)
+  end
+  
+  # Shorthand for Proc.new
+  # e.g. P{|r| puts r}
+  def P(&blk)
+    Proc.new(&blk)
+  end
+end
+
+class String
+  def /(*args)
+    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
+end
+
+class Array
+  def extract_options!
+    last.is_a?(Hash) ? pop : {}
+  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)
+    namespace = self.to_s.underscore
+    items.each do |item|
+      require File.join(namespace, item.to_s.underscore)
+    end
+  end
+  
+  def extends_library(*items)
+    namespace = self.to_s.underscore
+    items.each do |item|
+      klass = item.to_s.camelize.to_sym
+      # Load if it isn't loaded already.
+      const_get(klass) unless const_defined?(klass)
+      # And finally load the file.
+      require File.join(namespace, item.to_s.underscore)
+    end 
+  end
+  
+  def attempt_require(*files)
+    files.each do |file|
+      begin
+        require file
+      rescue LoadError
+      end
+    end
+  end
+  
+end

data/lib/perennial/core_ext.rb

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

data/lib/perennial/daemon.rb

@@ -0,0 +1,123 @@
+require 'fileutils'
+
+module Perennial
+  # = Perennial::Daemon provides a relatively simple
+  # interface to creating unix daemons from a given process.
+  # Namely, it focuses on three providing tools for
+  # a couple of simple purposes.
+  #
+  # == Turning a process into a daemon
+  #
+  # This approach is as as simple as calling
+  # Perennial::Daemon.daemonize! - the current process
+  # will then be a daemon, the non-daemon processes
+  # will be killed and if started by the loader, it will
+  # also write a pid out.
+  #
+  # == Checking whether a process is alive
+  #
+  # Perennial::Daemon.alive?(pid) is a super simple way
+  # to check if a pid (as an integer) is current active / alive,
+  # 
+  # Perennial::Daemon.any_alive? takes a type and tells you if
+  # any processes with the associated type are alive.
+  #
+  # == Storing / Retrieving Pids for a Given Loader Type
+  #
+  # Perennial::Daemon.daemonize! will store the pid for
+  # the current process if Perennial::Loader.current_type
+  # is present.
+  #
+  # Perennial::Daemon.any_alive?(type = :all) and
+  # Perennial::Daemon.kill_all(type = :all) can be
+  # used to deal with checking the status of and killing
+  # processes associated with a given loader type.
+  class Daemon
+    class << self
+      
+      def any_alive?(type = :all)
+        !pid_file_for(type).empty?
+      end
+      
+      # Returns true / false depending on whether
+      # a process with the given pid exists.
+      def alive?(pid)
+        return Process.getpgid(pid) != -1
+      rescue Errno::ESRCH
+        return false
+      end
+      
+      # Kills all processes associated with a certain app type.
+      # E.g. Given a loader is starting a :client, kill_all(:client)
+      # would kill all associated processes (usually after daemonizing)
+      # and kill_all would do the same - but if we also started
+      # a process for :server, kill_all(:client wouldn't kill the
+      # the process where as kill_all would.
+      def kill_all(type = :all)
+        kill_all_from(pid_file_for(type))
+        return false
+      end
+      
+      # Converts the current process into a Unix-daemon using
+      # the double fork approach. Also, changes process file
+      # mask to 000 and reopens STDIN / OUT to /dev/null
+      def daemonize!
+        exit if fork
+        Process.setsid
+        exit if fork
+        self.write_pid
+        File.umask    0000
+        STDIN.reopen  "/dev/null"
+        STDOUT.reopen "/dev/null", "a"
+        STDERR.reopen STDOUT
+        Perennial::Settings.verbose = false
+      end
+      
+      # Cleans up processes for the current application type
+      # (deteremined by the loader) and then removes the pid file.
+      def cleanup!
+        f = pids_file_for(Loader.current_type)
+        FileUtils.rm_f(f) if (pids_from(f) - Process.pid).blank?
+      end
+      
+      # Returns an array of pid's associated with a given type.
+      def pids_for_type(type)
+        pids_from(pid_file_for(type))
+      end
+      
+      protected
+
+      def kill_all_from(file)
+        pids = pids_from(file)
+        pids.each { |p| Process.kill("TERM", p) unless p == Process.pid }
+        FileUtils.rm_f(file)
+      rescue => e
+        STDOUT.puts e.inspect
+      end
+
+      def pid_file_for(type)
+        type = "*" if type == :all
+        Settings.root / "tmp" / "pids" / "#{type.to_s.underscore}.pid"
+      end
+
+      def pids_from(files)
+        pids = []
+        Dir[files].each do |file|
+          pids += File.read(file).split("\n").map { |l| l.strip.to_i(10) }
+        end
+        return pids.uniq.select { |p| alive?(p) }
+      end
+
+      def write_pid
+        type = Loader.current_type
+        return if type.blank?
+        f = pid_file_for(type)
+        pids = pids_from(f)
+        pids << Process.pid unless pids.include?(Process.pid)
+        FileUtils.mkdir_p(File.dirname(f))
+        File.open(f, "w+") { |f| f.puts pids.join("\n") }
+      end
+      
+    end
+  end
+end