perennial 1.0.1 → 1.0.2

data/lib/perennial/core_ext/ansi_formatter.rb

@@ -0,0 +1,142 @@
+module Perennial
+   class ANSIFormatter
+    
+    TAGS = {
+      :bold          => 1,
+      :italics       => 3,
+      :underline     => 4,
+      :inverse       => 7,
+      :strikethrough => 9
+    }
+    
+    COLOURS = {
+      :black         => 30,
+      :red           => 31,
+      :green         => 32,
+      :yellow        => 33,
+      :blue          => 34,
+      :magenta       => 35,
+      :cyan          => 36,
+      :white         => 37
+    }
+    
+    BACKGROUND_COLOURS = {
+      :bg_black      => 40,
+      :bg_red        => 41,
+      :bg_green      => 42,
+      :bg_yellow     => 43,
+      :bg_blue       => 44,
+      :bg_magenta    => 45,
+      :bg_cyan       => 46,
+      :bg_white      => 47
+    }
+    
+    
+    UNDO_TAGS = {
+      :all           => 0,
+      :bold          => 22,
+      :italics       => 23,
+      :underline     => 24,
+      :inverse       => 27,
+      :strikethrough => 29,
+      :colour        => 39,
+      :bg_colour     => 49
+    }
+    
+    MATCH_REGEXP = /\<f\:(.+)\>(.*)\<\/f\:\1>/
+    ESCAPE_TAG   = /\<\/?f\:escape\>/
+    ANSI_CODE    = /\033\[(?:\d+\;?)+m/
+    
+    cattr_accessor :formatted
+    @@formatted = true
+    
+    def initialize(string)
+      @string  = string
+    end
+    
+    def to_s
+      @@formatted ? to_formatted_s : to_normal_s
+    end
+    
+    def to_formatted_s
+      format_tags
+    end
+    
+    def to_normal_s
+      remove_tags
+    end
+    
+    class << self
+      
+      def format(tag, text)
+        tag = tag.to_s.gsub(/[\-\:]/, "_").to_sym
+        "\033[#{lookup_tag(tag)}m#{text}\033[#{lookup_end_tag(tag)}m"
+      end
+
+      def lookup_tag(tag)
+        TAGS[tag] || COLOURS[tag] || BACKGROUND_COLOURS[tag]
+      end
+      
+      def lookup_end_tag(tag)
+        UNDO_TAGS[lookup_tag_type(tag)] || UNDO_TAGS[:all]
+      end
+      
+      def lookup_tag_type(tag)
+        if COLOURS.has_key?(tag)
+          tag = :colour
+        elsif BACKGROUND_COLOURS.has_key?(tag)
+          tag = :bg_colour
+        end
+        tag
+      end
+      
+      def clean(text)
+        text = text.gsub(ESCAPE_TAG, "") while text =~ ESCAPE_TAG
+        text = text.gsub(ANSI_CODE,  "") while text =~ ANSI_CODE
+        text
+      end
+      
+      def process(string)
+        new(string).to_s
+      end
+      
+    end
+    
+    protected
+    
+    def format_tags(string = @string, tag_stack = nil, mapping = nil)
+      tag_stack ||= []
+      mapping   ||= Hash.new { |h,k| h[k] = [] }
+      string.gsub(MATCH_REGEXP) do
+        inner_text = $2
+        tag = $1.to_s.gsub(/[\-\:]/, "_").to_sym
+        type      = self.class.lookup_tag_type(tag)
+        start_tag = self.class.lookup_tag(tag)
+        end_tag   = UNDO_TAGS[type]
+        if tag == :escape 
+          inner_text
+        elsif end_tag.present?
+          mapping[type] << start_tag
+          text = "\033[#{start_tag}m#{format_tags(inner_text, (tag_stack + [:type]), mapping)}\033[#{end_tag}m"
+          mapping[type].pop
+          text << "\033[#{mapping[type].join(";")}m"
+        else
+          format_tags(inner_text, tag_stack, mapping)
+        end
+      end
+    end
+    
+    def remove_tags(string = @string)
+      string.gsub(MATCH_REGEXP) { remove_tags($2) }
+    end
+    
+  end
+end
+
+class String
+  
+  def to_ansi
+    Perennial::ANSIFormatter.process(self)
+  end
+  
+end

data/lib/perennial/core_ext/hash_key_conversions.rb

@@ -6,15 +6,11 @@ class Hash
   end
   
   def symbolize_keys!
-    hash = {}
-    self.each_pair { |k,v| hash[k.to_sym] = v }
-    replace hash
+    convert_keys_via :to_sym
   end
   
   def stringify_keys!
-    hash = {}
-    self.each_pair { |k, v| hash[k.to_s] = v }
-    replace hash
+    convert_keys_via :to_s
   end
   
   def stringify_keys
@@ -23,4 +19,12 @@ class Hash
     return hash
   end
   
+  protected
+  
+  def convert_keys_via(method)
+    hash = {}
+    self.each_pair { |k,v| hash[k.send(method)] = v }
+    replace hash
+  end
+  
 end

data/lib/perennial/core_ext.rb

@@ -4,4 +4,5 @@ require 'perennial/core_ext/blank'
 require 'perennial/core_ext/misc'
 require 'perennial/core_ext/hash_key_conversions'
 require 'perennial/core_ext/inflections'
-require 'perennial/core_ext/proxy'
+require 'perennial/core_ext/proxy'
+require 'perennial/core_ext/ansi_formatter'

data/lib/perennial/daemon.rb

@@ -33,6 +33,8 @@ module Perennial
   # used to deal with checking the status of and killing
   # processes associated with a given loader type.
   class Daemon
+    include Perennial::Loggable
+    
     class << self
       
       def any_alive?(type = :all)
@@ -42,9 +44,12 @@ module Perennial
       # Returns true / false depending on whether
       # a process with the given pid exists.
       def alive?(pid)
-        return Process.getpgid(pid) != -1
+        Process.kill(0, pid)
+        return true
       rescue Errno::ESRCH
         return false
+      rescue SystemCallError => e
+  			return true
       end
       
       # Kills all processes associated with a certain app type.
@@ -61,16 +66,20 @@ module Perennial
       # 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!
-        fork_off_and_die
-        Process.setsid
-        fork_off_and_die
-        self.write_pid
-        File.umask    0000
-        STDIN.reopen  "/dev/null"
-        STDOUT.reopen "/dev/null", "a"
-        STDERR.reopen STDOUT
-        Perennial::Settings.verbose = false
+      def daemonize!(should_exit = true)
+        if detached_fork { exit if should_exit }
+          Process.setsid
+          detached_fork { exit }
+          reinitialize_stdio
+          yield if block_given?
+        end
+      end
+      
+      def daemonize_current_type!
+        daemonize! do
+          write_pid
+          Perennial::Settings.verbose = false
+        end
       end
       
       # Cleans up processes for the current application type
@@ -87,12 +96,19 @@ module Perennial
       
       protected
 
+      def reinitialize_stdio
+        File.umask    0000
+        STDIN.reopen  "/dev/null"
+        STDOUT.reopen "/dev/null", "a"
+        STDERR.reopen STDOUT
+      end
+
       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
+        Perennial::Logger.log_exception(e)
       end
 
       def pid_file_for(type)
@@ -105,7 +121,7 @@ module Perennial
         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) }
+        pids.uniq.select { |p| alive?(p) }
       end
 
       def write_pid
@@ -118,11 +134,13 @@ module Perennial
         File.open(f, "w+") { |f| f.puts pids.join("\n") }
       end
       
-      def fork_off_and_die
-        if pid = fork
+      def detached_fork
+        pid = fork
+        unless pid.nil?
           Process.detach(pid)
-          exit
+          yield if block_given?
         end
+        pid
       end
       
     end

data/lib/perennial/dispatchable.rb

@@ -59,7 +59,6 @@ module Perennial
           Logger.debug "Dispatching #{name} event (#{dispatch_queue.size} queued - on #{self.class.name})"
           # Add ourselves to the queue
           @dispatching = true
-          # TODO: improve performance. This should be dispatched per-request cycle.
           pre_dispatching
           begin
             # The full handler name is the method we call given it exists.

data/lib/perennial/generator.rb

@@ -6,6 +6,22 @@ require 'readline'
 module Perennial
   class Generator
     
+    class HashBinding
+      
+      def initialize(hash)
+        hash.each_pair { |k, v| instance_variable_set("@#{k}", v) }
+      end
+      
+      def to_binding
+        return binding()
+      end
+      
+      def self.for(h)
+        new(h).to_binding
+      end
+      
+    end
+    
     class CommandEnv < Perennial::Application::CommandEnv
       
       def initialize
@@ -93,21 +109,13 @@ module Perennial
     
     def template(source, destination, environment = {}, append = false)
       describe "Processing template #{source}"
-      raw_template = File.read(expand_template_path(source))
-      processed_template = ERB.new(raw_template).result(binding_for(environment))
+      raw_template = File.read(expand_template_path(source.to_s))
+      processed_template = ERB.new(raw_template).result(HashBinding.for(environment))
       file destination, processed_template, append
     end
     
     protected
     
-    def binding_for(hash = {})
-      object = Object.new
-      hash.each_pair do |k, v|
-        object.instance_variable_set("@#{k}", v)
-      end
-      return object.send(:binding)
-    end
-    
     def expand_template_path(p)
       File.expand_path(p, @template_path)
     end

data/lib/perennial/loader.rb

@@ -33,7 +33,7 @@ module Perennial
     def run!(options = {})
       self.register_signals
       self.class.invoke_hooks! :before_setup
-      Daemon.daemonize! if Settings.daemon?
+      Daemon.daemonize_current_type! if Settings.daemon?
       Logger.log_name = "#{@@current_type.to_s}.log"
       Logger.setup
       Settings.setup

data/lib/perennial/logger.rb

@@ -40,6 +40,11 @@ module Perennial
        @@logger.send(name, *args, &blk)
       end
       
+      def warn(message)
+        self.setup
+        @@logger.warn(message)
+      end
+      
       def respond_to?(symbol, include_private = false)
         self.setup
         super(symbol, include_private) || @@logger.respond_to?(symbol, include_private)
@@ -57,14 +62,14 @@ module Perennial
   
     PREFIXES = {}
   
-    LEVELS.each { |k,v| PREFIXES[k] = "[#{k.to_s.upcase}]".ljust 7 }
+    LEVELS.each { |k,v| PREFIXES[k] = "[#{k.to_s.upcase}]".rjust 7 }
 
     COLOURS = {
-      :fatal => 31, # red
-      :error => 33, # yellow
-      :warn  => 35, # magenta
-      :info  => 32, # green
-      :debug => 34  # white
+      :fatal => "red",
+      :error => "yellow",
+      :warn  => "magenta",
+      :info  => "green",
+      :debug => "blue"
     }
   
     attr_accessor :level, :file, :verbose
@@ -74,6 +79,7 @@ module Perennial
       @verbose = verbose
       FileUtils.mkdir_p(File.dirname(path))
       @file    = File.open(path, "a+")
+      @file.sync = true if @file.respond_to?(:sync=)
     end
   
     def close!
@@ -82,7 +88,7 @@ module Perennial
   
     LEVELS.each do |name, value|
       define_method(name) do |message|
-        write("#{PREFIXES[name]} #{message}", name) if LEVELS[@level] <= value
+        write(message.to_s, name) if LEVELS[@level] <= value
       end
     
       define_method(:"#{name}?") do
@@ -105,13 +111,10 @@ module Perennial
     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"
+      c = COLOURS[level]
+      message = ANSIFormatter.new("<f:#{c}>#{PREFIXES[level]}</f:#{c}> #{ANSIFormatter.clean(message)}")
+      @file.puts   message.to_normal_s
+      $stdout.puts message.to_formatted_s if verbose?
     end
  
     

data/lib/perennial/reloading.rb

@@ -1,5 +1,6 @@
 module Perennial
   class Reloading
+    include Perennial::Loggable
     
     cattr_accessor :mapping, :mtimes
     self.mapping = {}
@@ -9,7 +10,7 @@ module Perennial
       file = File.expand_path(file)
       raise ArgumentError, "You must provide the path to a file" unless File.file?(file)
       relative = file.gsub(/^#{File.expand_path(relative_to)}\//, '')
-      name = relative.gsub(/\.rb$/, '').split("/").map { |part|part.camelize }.join("::")
+      name = relative.gsub(/\.rb$/, '').split("/").map { |part| part.camelize }.join("::")
       self.mapping[name] = file
       self.mtimes[file] = File.mtime(file)
     end

data/lib/perennial/settings.rb

@@ -79,6 +79,7 @@ module Perennial
       def update!(attributes = {})
         return if attributes.blank?
         settings_file = self.default_settings_path
+        FileUtils.mkdir_p(File.dirname(settings_file))
         settings = File.exist?(settings_file) ? YAML.load(File.read(settings_file)) : {}
         namespaced_settings = lookup_settings_from(settings)
         namespaced_settings.merge! attributes.stringify_keys

data/lib/perennial.rb

@@ -9,7 +9,7 @@ require 'perennial/exceptions'
 
 module Perennial
   
-  VERSION = [1, 0, 1, 0]
+  VERSION = [1, 0, 2, 0]
   
   has_library :dispatchable, :hookable, :loader, :logger, :nash,
               :loggable, :manifest, :settings, :argument_parser,

data/test/argument_parser_test.rb

@@ -0,0 +1,56 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+require 'shellwords'
+
+class ArgumentParserTest < Test::Unit::TestCase
+  
+  context 'simple argument parsing' do
+    
+    should 'correct parse arguments using no options' do
+      args, hash = parse("a b c")
+      assert_equal({}, hash)
+      assert_equal ["a", "b", "c"], args
+    end
+    
+    should 'correct parse arguments using only short formats' do
+      args, hash = parse("-a -b=1 -c 3")
+      assert_equal [], args
+      assert_equal({"a" => true, "b" => "1", "c" => "3"}, hash)
+    end
+    
+    should 'correct parse arguments using only long format' do
+      args, hash = parse("--ninjas --rockn=roll --awesome sauce")
+      assert_equal [], args
+      assert_equal({
+        "ninjas"  => true,
+        "rockn"   => "roll",
+        "awesome" => "sauce"
+      }, hash)
+    end
+    
+    should 'correct parse arguments using mixed arguments' do
+    args, hash = parse("client --verbose --l=debug --user sutto another-arg")
+    assert_equal ["client", "another-arg"], args
+    assert_equal({
+      "verbose" => true,
+      "l"       => "debug",
+      "user"    => "sutto"
+    }, hash)
+    end
+    
+    should 'correct differentiate between --value=a and --value b' do
+      args, hash = parse("--felafel value beat")
+      assert_equal ["beat"], args
+      assert_equal({"felafel" => "value"}, hash)
+      args, hash = parse("--felafel=value beat")
+      assert_equal ["beat"], args
+      assert_equal({"felafel" => "value"}, hash)
+    end
+    
+  end
+  
+  def parse(s)
+    Perennial::ArgumentParser.parse Shellwords.shellwords(s)
+  end
+  
+end

data/test/delegateable_test.rb

@@ -28,8 +28,8 @@ class DelegateableTest < Test::Unit::TestCase
     should 'let you get the real target of the delegate' do
       @delegateable.delegate_to :awesome
       assert real = @delegateable.real_delegate
-      assert_raises(NoMethodError) { proxy.awesomesauce }
-      assert_raises(NoMethodError) { proxy.ninja_party }
+      assert_raises(NoMethodError) { real.awesomesauce }
+      assert_raises(NoMethodError) { real.ninja_party }
       assert_equal "awesome", real.to_s
     end
     

data/test/dispatchable_test.rb

@@ -132,30 +132,28 @@ class DispatchableTest < Test::Unit::TestCase
     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.expects(:respond_to?).with(:handle_sample_event).returns(true)
+      @dispatcher.expects(:handle_sample_event).with(: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)
+      @handler.expects(:respond_to?).with(:handle_sample_event).returns(true)
+      @handler.expects(:handle_sample_event).with(: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)
+    should 'XXX call handle on each handler if handle_[event_name] isn\'t defined' do
+      @handler.expects(:respond_to?).with(:handle_sample_event).returns(false)
+      @handler.expects(:handle).with(: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)
+      @handler.expects(:handle).with(:sample_event, :awesome => true, :sauce => 2).raises(Perennial::HaltHandlerProcessing)
+      handler_two.expects(:handle).with(:sample_event, :awesome => true, :sauce => 2).never
       @dispatcher.dispatch :sample_event, :awesome => true, :sauce => 2
     end
     
@@ -203,7 +201,7 @@ class DispatchableTest < Test::Unit::TestCase
     end
     
     should 'call registered= on the handler' do
-      mock(@handler).registered = true
+      @handler.expects(:registered=).with(true)
       @dispatcher.class.register_handler @handler
     end
     

data/test/generator_test.rb

@@ -0,0 +1,94 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class GeneratorTest < Test::Unit::TestCase
+  context 'a basic generator' do
+    
+    setup do
+      @generator_dir = Pathname(__FILE__).dirname.join("..", "generator-test").expand_path
+      FileUtils.mkdir_p(@generator_dir)
+      @generator = Perennial::Generator.new(@generator_dir, :silent => true)
+    end
+    
+    should 'let you create folders' do
+      assert !File.directory?(File.join(@generator_dir, "test-a"))
+      assert !File.directory?(File.join(@generator_dir, "test-b"))
+      assert !File.directory?(File.join(@generator_dir, "test-c"))
+      assert !File.directory?(File.join(@generator_dir, "test-c/subdir"))
+      @generator.folders 'test-a', 'test-b', 'test-c/subdir'
+      assert File.directory?(File.join(@generator_dir, "test-a"))
+      assert File.directory?(File.join(@generator_dir, "test-b"))
+      assert File.directory?(File.join(@generator_dir, "test-c"))
+      assert File.directory?(File.join(@generator_dir, "test-c/subdir"))
+    end
+    
+    should 'define a shortcut for FileUtils' do
+      assert_equal FileUtils, @generator.fu
+    end
+    
+    should 'let you chmod a file' do
+      test_file = Pathname(@generator_dir).join("test-file").expand_path
+      File.open(test_file, "w+") { |f| f.puts "Some Simple File" }
+      old_permissions = File.stat(test_file).mode
+      @generator.chmod 0755, "test-file"
+      new_permissions = File.stat(test_file).mode
+      assert_not_equal old_permissions, new_permissions
+      assert_equal 0100755, new_permissions
+    end
+    
+    should 'let you easily check if a file exists' do
+      assert !@generator.file?("test-file")
+      test_file = Pathname(@generator_dir).join("test-file").expand_path
+      File.open(test_file, "w+") { |f| f.puts "Some Simple File" }
+      assert @generator.file?("test-file")
+    end
+    
+    should 'let you easily check if a directory exists' do
+      assert !@generator.directory?("test-dir")
+      FileUtils.mkdir Pathname(@generator_dir).join("test-dir").expand_path
+      assert @generator.directory?("test-dir")
+    end
+    
+    should 'let you easily check if a file is executable' do
+      test_file = Pathname(@generator_dir).join("test-file").expand_path
+      File.open(test_file, "w+") { |f| f.puts "#!/bin/sh" }
+      assert !@generator.executable?("test-file")
+      File.chmod 0755, test_file
+      assert @generator.executable?("test-file")
+    end
+    
+    should 'let you generate a file with contents' do
+      test_file = Pathname(@generator_dir).join("test-file").expand_path
+      @generator.file("test-file", "Example File")
+      assert_equal "Example File", File.read(test_file)
+      @generator.file("test-file", "Example File 2")
+      assert_equal "Example File 2", File.read(test_file)
+    end
+    
+    should 'let you generate a file with contents, possibly appending' do
+      test_file = Pathname(@generator_dir).join("test-file").expand_path
+      @generator.file("test-file", "Example File")
+      assert_equal "Example File", File.read(test_file)
+      @generator.file("test-file", " 2", true)
+      assert_equal "Example File 2", File.read(test_file)
+    end
+    
+    should 'let you render a template' do
+      test_file = @generator_dir.join("test-file").expand_path
+      template_dir = @generator_dir.join("templates")
+      FileUtils.mkdir_p template_dir
+      File.open(template_dir.join("sample.erb"), "w+") { |f| f.puts "Hello <%= @name %>" }
+      @generator.template_path = template_dir.to_s
+      assert !File.file?(test_file)
+      @generator.template "sample.erb", "test-file", :name => "Darcy"
+      assert File.file?(test_file)
+      assert_equal "Hello Darcy", File.read(test_file).strip
+    end
+    
+    should 'let you download file and save it'
+    
+    teardown do
+      FileUtils.rm_rf(@generator_dir) if File.directory?(@generator_dir)
+    end
+    
+  end
+end

data/test/logger_test.rb

@@ -1,59 +1,58 @@
 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
+  with_fakefs do
+    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
+      context 'setting up a logger' do
     
-      setup { Perennial::Logger.setup! }
+        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
+        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
+        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
-      end
     
-      should 'have a log exception method' do
-        assert Perennial::Logger.respond_to?(:log_exception)
-        assert Perennial::Logger.logger.respond_to?(:log_exception)
-      end
+        should 'have a log exception method' do
+          assert Perennial::Logger.respond_to?(:log_exception)
+          assert Perennial::Logger.logger.respond_to?(:log_exception)
+        end
       
-      should 'let you configure a dir that logs are loaded from'
+        should 'let you configure a dir that logs are loaded from'
     
-    end
+      end
   
-    context 'writing to the log' do
+      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")
+        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
       
-    end
+      end
   
-    teardown do
-      log_path = @root_path / "example.log"
-      FileUtils.rm_rf(log_path) if File.exist?(log_path)
+      teardown do
+        log_path = @root_path / "example.log"
+        FileUtils.rm_rf(log_path) if File.exist?(log_path)
+      end  
     end
-    
   end
-  
 end

data/test/option_parser_test.rb

@@ -0,0 +1,52 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+require 'shellwords'
+
+class OptionParserTest < Test::Unit::TestCase
+  context 'basic option parsing' do
+    
+    setup do
+      @options = {}
+      @option_parser = Perennial::OptionParser.new
+      @option_parser.add(:age, "Your age") { |v| @options[:age] = v.to_i }
+      @option_parser.add(:name, "Your name") { |v| @options[:name] = v.to_s }
+      @option_parser.add(:ninja, "Are you a ninja") { |v| @options[:ninjas] = v.present? }
+      @option_parser.add(:felafel, "Do you enjoy felafel?", :shortcut => "X") { |v| @options[:felafel] = v.present? }
+    end
+    
+    should 'correct recognize short options' do
+      parse! "-a 18 -n \"Darcy Laycock\" -N -X"
+      assert_equal({
+        :age => 18,
+        :name => "Darcy Laycock",
+        :ninjas => true,
+        :felafel => true
+      }, @options)
+    end
+    
+    should 'correctly recognize long options' do
+      parse! "--age 21 --name \"Darcy Laycock\" --ninja --felafel"
+      assert_equal({
+        :age => 21,
+        :name => "Darcy Laycock",
+        :ninjas => true,
+        :felafel => true
+      }, @options)
+    end
+    
+    should 'correctly recognize mixed options' do
+      parse! "-a 21 --name \"Darcy Laycock\" -N --felafel"
+      assert_equal({
+        :age => 21,
+        :name => "Darcy Laycock",
+        :ninjas => true,
+        :felafel => true
+      }, @options)
+    end
+      
+  end
+  
+  def parse!(l)
+    @option_parser.parse(Shellwords.shellwords(l))
+  end
+  
+end

data/test/reloading_test.rb

@@ -0,0 +1,75 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class ReloadingTest < Test::Unit::TestCase
+  
+  context 'basic reloading file' do
+    
+    setup do
+      @file = File.join(File.dirname(__FILE__), "tmp", "reloading_test.rb")
+      FileUtils.mkdir_p File.dirname(@file)
+      write_reloadable_klass(:initial)
+      load @file
+      Perennial::Reloading.watch @file
+      ReloadingTest.count = 10
+    end
+    
+    should 'call reloading on the old class if defined' do
+      ReloadingTest.expects(:respond_to?).with(:reloading!).returns(true)
+      ReloadingTest.expects(:reloading!)
+      write_reloadable_klass :reloaded
+      Perennial::Reloading.reload!
+    end
+    
+    should 'call reloaded if defined' do
+      assert !ReloadingTest.was_reloaded
+      # Reload without the method
+      write_reloadable_klass :reloaded
+      Perennial::Reloading.reload!
+      assert !ReloadingTest.was_reloaded
+      # finally, define the method and reload.
+      write_reloadable_klass :reloaded, true
+      Perennial::Reloading.reload!
+      assert ReloadingTest.was_reloaded
+    end
+    
+    should 'reload if changed' do
+      assert_equal 10, ReloadingTest.count
+      assert_equal :initial, ReloadingTest::RELOADED_VALUE
+      write_reloadable_klass :reloaded
+      Perennial::Reloading.reload!
+      assert_equal 0, ReloadingTest.count
+      assert_equal :reloaded, ReloadingTest::RELOADED_VALUE
+    end
+    
+    should 'not reload if unchanged' do
+      assert_equal 10, ReloadingTest.count
+      assert_equal :initial, ReloadingTest::RELOADED_VALUE
+      Perennial::Reloading.reload!
+      assert_equal 10, ReloadingTest.count
+      assert_equal :initial, ReloadingTest::RELOADED_VALUE
+    end
+    
+    teardown do
+      File.delete @file if File.exist?(@file)
+      Object.send(:remove_const, :ReloadingTest) if defined?(ReloadingTest)
+    end
+    
+  end
+  
+  def write_reloadable_klass(value, include_reloaded = false)
+    u, a = Time.now, Time.now
+    u, a = File.atime(@file), File.mtime(@file) if File.exist?(@file)
+    File.open(@file, "w+") do |f|
+      f.puts "class ReloadingTest"
+      f.puts "  RELOADED_VALUE = #{value.inspect}"
+      f.puts "  cattr_accessor :count"
+      f.puts "  self.count = 0"
+      f.puts "  cattr_reader :was_reloaded"
+      f.puts "  def self.reloaded!; @@was_reloaded = true; end" if include_reloaded
+      f.puts "end"
+    end
+    # We fake the mtime to simulate a proper, delay
+    File.utime(u + 3, a + 3, File.expand_path(@file))
+  end
+  
+end

data/test/settings_test.rb

@@ -1,103 +1,103 @@
 require File.join(File.dirname(__FILE__), "test_helper")
 
 class SettingsTest < Test::Unit::TestCase
-  
-  context 'default settings' do
+  with_fakefs do
+    context 'default settings' do
     
-    setup do
-      Perennial::Settings.setup!
-    end
+      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 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 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 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
+      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
+    end
   
-  context 'loading settings' do
+    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"]
+      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)
+        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
-      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 '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)
+      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
-    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]
+      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
-    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)
+      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
     
-    should 'let you configure the lookup key path'
+      should 'let you configure the lookup key path'
     
-    should 'let you configure the file settings are loaded from'
+      should 'let you configure the file settings are loaded from'
     
+    end
   end
-  
 end

data/test/test_helper.rb

@@ -3,17 +3,26 @@ require 'rubygems'
 # Testing dependencies
 require 'test/unit'
 require 'shoulda'
-require 'rr'
+require 'mocha'
 # 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")
+# Require fakefs
+$:.unshift root_directory.join("vendor", "fakefs", "lib").to_s
+require "fakefs/safe"
 
 class Test::Unit::TestCase
-  include RR::Adapters::TestUnit
+  
+  def self.with_fakefs(&blk)
+    context '' do
+      setup { FakeFS.activate! }
+      context('', &blk)
+      teardown { FakeFS.deactivate! }
+    end
+  end
   
   protected
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: perennial
 version: !ruby/object:Gem::Version 
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors: 
 - Darcy Laycock
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-05 00:00:00 +08:00
+date: 2009-10-09 00:00:00 +08:00
 default_executable: perennial
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,6 +22,16 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
     version: 
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
 - !ruby/object:Gem::Dependency 
   name: yard
   type: :development
@@ -46,6 +56,7 @@ files:
 - lib/perennial/application.rb
 - lib/perennial/argument_parser.rb
 - lib/perennial/core_ext.rb
+- lib/perennial/core_ext/ansi_formatter.rb
 - lib/perennial/core_ext/attribute_accessors.rb
 - lib/perennial/core_ext/blank.rb
 - lib/perennial/core_ext/hash_key_conversions.rb
@@ -103,12 +114,16 @@ signing_key:
 specification_version: 3
 summary: A simple (generally event-oriented) application library for Ruby
 test_files: 
+- test/argument_parser_test.rb
 - test/delegateable_test.rb
 - test/dispatchable_test.rb
+- test/generator_test.rb
 - test/hookable_test.rb
 - test/loader_test.rb
 - test/loggable_test.rb
 - test/logger_test.rb
+- test/option_parser_test.rb
 - test/proxy_test.rb
+- test/reloading_test.rb
 - test/settings_test.rb
 - test/test_helper.rb