watcher 1.1.0

data/lib/watcher.rb

@@ -0,0 +1,596 @@
+#!/usr/bin/ruby -w
+# -*- Ruby -*-
+# Watcher
+#
+# Summary::   Watcher provides advanced integrated exception handling and
+#             logging functionality to your Ruby programs.
+# Author::    Karrick McDermott (karrick@karrick.org)
+# Date::      2008-07-04
+# Copyright:: Copyright (c) 2008 by Karrick McDermott.  All rights reserved.
+# License::   Simplified BSD License.
+
+######################################################################
+class Watcher
+  VERSION = '1.1.0'
+  # Tracks the number of times an Exception has invoked the :raise fail
+  # action.
+  # * Fail actions to log an error (:log), invoke a Proc (lambda {...}), and
+  #   retry (:retry) are ignored because flow of the program is allowed to
+  #   continue for each of those, whereas a :raise will abort processing of
+  #   subsequent tasks until caught.
+  # * If a task raises an Exception, but the task is enclosed in another task
+  #   that merely logs the Exception, then the @errors attribute is still
+  #   incremented.  This is useful for signalling when a warning condition
+  #   occured, but the program is able to continue the processing of
+  #   subsequent tasks.
+  attr_reader :errors
+  
+  # Tracks the number of times an Exception has been raised, regardless of
+  # whether the Exception was re-thrown.
+  attr_reader :warnings
+
+  # Array of actions to perform when an Exception is thrown by code in the
+  # yield block.
+  # * The Watcher instance maintains a default @fail_actions Array for use
+  #   when a given invocation does not specify a different set of actions to
+  #   perform.
+  # * The default value is an Array of two actions, [:log, :raise], which
+  #   notes the error in the logs, and re-throws the Exception.
+  attr_accessor :fail_actions
+  
+  # A String to include inside the log entry when an Exception is thrown.
+  # * This may be required in some circumstances where a separate log
+  #   monitoring program is scanning log files looking for a string such as,
+  #   ERROR or FAILURE.
+  # * The default value is nil.
+  attr_accessor :fail_symbol
+
+  # The number of spaces to indent a child level task under its parent task.
+  # * A Boolean value of false or an Integer value of 0 turns off indentation.
+  # * Any other value will set how many characters will be used for indenting
+  #   the logs.
+  # * This may only be set at the time the Watcher object is created.
+  # * The default value is 3.
+  attr_reader   :indent
+
+  # A String of characters to use when joining multiple error lines into a
+  # single line for output to the log.
+  # * If nil, the Exception message is reported verbatim.  If not nil, the
+  #   value must respond to the <tt>to_s</tt> method, which is used to join
+  #   the Exception message lines.
+  # * The default value is ' (LF) '.
+  attr_accessor :merge_newlines
+
+  # Determines whether Watcher will display the task completion log events.
+  # * The default value is false.
+  attr_accessor :show_completion
+  
+  # Holds a Proc object assigned the task of formatting the system time to a
+  # String for display.
+  # * You can easily change how the times are displayed by passing a Proc
+  #   object or a block to this attribute.
+  # * If you pass a block, be sure to wrap it with lambda.
+  #
+  #   <tt>$watcher.time_format( lambda { Time.now.utc } )</tt>
+  #
+  # * The default value is a Proc object that returns a String representing
+  #   local time in the standard system format.
+  attr_accessor :time_formatter
+
+  # Determines level of reporting that Watcher object sends to the log file.
+  # * Possible values are the Symbols :debug, :info, :warn, :error, and
+  #   :fatal.
+  # * The default value is :info.
+  attr_accessor :verbosity
+
+  # Provide ability for Watcher to prioritize levels of verbosity.
+  # * It wasn't designed to be directly used by client code, but I suppose it
+  #   could be modified by consumer code in this script if the situation
+  #   warranted.
+  @@verbosity_levels = {:debug=>0, :info=>1, :warn=>2, :error=>3, :fatal=>4}
+
+  # Stores the Strings used by Watcher to use when writting events to the log
+  # files.
+  # * Provided as a means to customize the output, say for language
+  #   localization purposes.
+  # * <b>Warning</b>, if you substitute your own Hash for @verbosity_strings
+  #   that does not have keys for the five levels of verbosity used by
+  #   Watcher, you may cause Watcher to start throwing exceptions with it
+  #   attempts to coerce the NilClass into a String.
+  # * The default value of @verbosity_strings is a Hash that maps the
+  #   verbosity levels to a reasonable String value.
+  attr_accessor :verbosity_strings
+
+  # We override the default accessibility for the :new method because we want
+  # to ensure there is only one Watcher object created.
+  private_class_method :new
+  @@watcher = nil
+
+  # #Watcher.create is the only way to instantiate a new Watcher object.
+  # * You cannot use the #new method directly as you can with regular classes.
+  # * Repeated calls to #Watcher.create simply return the same Watcher object.
+  # * When a Watcher object is created, the default class initialization
+  #   values are usually perfectly suitable for the task at hand.  This is
+  #   more-so true when just starting on a new project, when the default is to
+  #   send logging information to STDERR, which is usually what you want when
+  #   developing a program using the interactive method, such as with irb.
+  # * It is easy to change any of the class attributes either at object
+  #   instantiation, or while the program is being executed. During
+  #   instantiation simply create a Hash object with a key Symbol for every
+  #   attribute you wish to change, whose value is your desired value.  For
+  #   instance, to create a globabl variable, aptly named <tt>$watcher</tt>:
+  #
+  # <tt>
+  # $watcher = Watcher.create({:fail_actions=>:warn, :verbosity=>:info})
+  # </tt>
+  #
+  # * Each Watcher object instance stores an IO object for buffering data to
+  #   the output log.  This can either be a regular file, STDERR, STDOUT, or
+  #   perhaps a FIFO or a pipe.  If you do not want to use STDERR or a
+  #   regular file, simply make the connection, and pass it to your Watcher
+  #   instance.
+  # * The default value of @output is an IO instance of STDERR.
+  def Watcher.create(attributes={})
+    @@watcher ||= new(attributes)
+  end
+
+  # Used to identify a low-level task during development.
+  # * This is most frequently invoked without a block, in which case it simply
+  #   appends the task start and stop messages to the log if the verbosity
+  #   level is at :debug.
+  # * Use this when in lieu of a group of 'puts' statements littered through
+  #   your source code.
+  # * See detailed decription for #monitor for how this method works.
+  def debug(task, fail_actions=@fail_actions)
+    monitor(task,:debug,block_given?,fail_actions) { yield }
+  end
+
+  # Usually the method of choice for your general logging purpose
+  # needs.
+  # * I typcially use it at every level of the stack frame to track the
+  #   progress of the program.
+  # * I recommend using this for every level of program logic that you desire
+  #   to track.
+  # * See detailed decription for #monitor for how this method works.
+  def info(task, fail_actions=@fail_actions)
+    monitor(task,:info,block_given?,fail_actions) { yield }
+  end
+
+  # Each Watcher object instance can optionally send a copy of its
+  # log file to a given email account.
+  # * You might want to call this if there were any errors while completing
+  #   your tasks.
+  def send_email(email,subject)
+    @output.flush    # flush the output buffer
+    system "mail -s '#{subject}' #{email} < #{@output_path}"
+
+    # reopen the output buffer for append mode
+    @output = File.open(@output_path, 'a')
+    unless @output # Redirect to STDERR if open failed.
+      @output = STDERR
+      @debug_out << "could not open [#{output}]. " + e.message + "\n" \
+        if WATCHER_DEBUG
+    end
+  end
+
+  ########################################
+  private
+  ########################################
+  
+  # The Watcher.initialize method is called by the Watcher.new method as
+  # normal, however because the Watcher.new method is a private method, the
+  # only way to create a new Watcher object is to use the Watcher.create
+  # method, which in turn invokes Watcher.new, which--finally--invokes
+  # Watcher.initialize.
+  def initialize(attributes={}) #:nodoc: #:notnew:
+    # Watcher debugging facility
+    if WATCHER_DEBUG
+      # Open our dump file, and let Ruby environment close it when we exit.
+      begin
+        # mode 'w' truncates file if not empty.
+        @debug_out = File.open(WATCHER_DEBUG_OUTPUT_FILENAME,'w')
+      rescue Exception => e
+        # if we couldn't open it, just send debugging data to STDERR,
+        # and insert a message indicating the failure.
+        @debug_out = STDERR
+        @debug_out << "could not open [#{WATCHER_DEBUG_OUTPUT_FILENAME}]. " \
+           + e.message + "\n"
+      end
+    end
+    
+    # Watcher debugging facility
+    if WATCHER_DEBUG and WATCHER_DEBUG_ATTRIBUTES
+      @debug_out << "=== Explicitly requested attributes: \n"
+      attributes.keys.each do |k|
+        @debug_out << "\t:#{k}=>#{attributes[k].inspect}\n"
+      end
+    end
+
+    # Here we define the default values for a newly created Watcher object.
+    # * If passed nil on :output, must specifically delete Hash key.
+    # * Merge the input attributes Hash given to Watcher.create with a
+    #   local inline Hash below.
+    # * Any keys provided by the user simply cause the associated key
+    #   values provided by the consumer code to overwrite the values
+    #   provided in the literal Hash below.  Isn't Ruby fun?
+    attributes.delete(:output) if attributes[:output] == nil
+    attributes={:fail_actions=>[:log,:raise], :fail_symbol=>nil, :indent=>3,
+      :merge_newlines=>' (LF) ', :output=>STDERR, :show_completion=>false,
+      :time_formatter=>lambda { Time.now.to_s }, :verbosity=>:info,
+      :verbosity_strings=>{:debug=>' DEBUG:',:info=>' INFO :',
+        :warn=>' WARN :',:error=>' ERROR:',
+        :fatal=>' FATAL:'}
+    }.merge(attributes)
+    
+    # Watcher debugging facility
+    if WATCHER_DEBUG and WATCHER_DEBUG_ATTRIBUTES
+      @debug_out << "=== Merged attributes: \n" << "\n"
+      attributes.keys.each do |k|
+        @debug_out << "\t:#{k}=>#{attributes[k].inspect}\n"
+      end
+    end
+    
+    # Here the product of the merges Hashes is used to populate the
+    # instantiated Watcher object attributes.
+    # Nothing to see here, move on...  Unless you want to improve
+    # Watcher...
+    @current_indent=0
+    @errors=0
+    @warnings=0
+    @fail_actions=attributes[:fail_actions]
+    @fail_symbol=attributes[:fail_symbol]
+    @indent=attributes[:indent]
+    @merge_newlines=attributes[:merge_newlines]
+    @output=attributes[:output]
+    @show_completion=attributes[:show_completion]
+    @time_formatter=attributes[:time_formatter]
+    @verbosity=attributes[:verbosity]
+    @verbosity_strings=attributes[:verbosity_strings]
+    
+    # Watcher debugging facility
+    if WATCHER_DEBUG and WATCHER_DEBUG_ATTRIBUTES
+      @debug_out << "=== Instance attributes: \n" << "\n"
+      @debug_out << "    @current_indent\t\t=#{@current_indent}" << "\n"
+      @debug_out << "    @fail_actions\t\t=#{@fail_actions.inspect}" << "\n"
+      @debug_out << "    @fail_symbol\t\t=\"#{@fail_symbol}\"" << "\n"
+      @debug_out << "    @indent\t\t\t=#{@indent}" << "\n"
+      @debug_out << "    @merge_newlines\t\t=#{@merge_newlines}" << "\n"
+      @debug_out << "    @output\t\t\t=#{@output}" << "\n"
+      @debug_out << "    @show_completion\t\t=#{@show_completion}" << "\n"
+      @debug_out << "    @time_formatter\t\t=#{@time_formatter}" << "\n"
+      @debug_out << "    @verbosity\t\t\t=:#{@verbosity}" << "\n"
+      @debug_out << "    @verbosity_strings\t\t=" \
+        + "#{@verbosity_strings.inspect}\n"
+    end
+    
+    # Open the log file if not STDERR nor STDOUR
+    if @output != STDERR and @output != STDOUT
+      @output_path = File.expand_path(@output)
+      # mode 'w' truncates file if not empty.
+      @output = File.open(@output_path, 'w')
+      unless @output # Redirect to STDERR if open failed.
+        @output = STDERR
+        @debug_out << "could not open [#{output}]. " + e.message + "\n" \
+          if WATCHER_DEBUG
+      end
+    end
+  end # initialize
+  
+  # Returns a String representing the indentation characters to use
+  # for the event.
+  # * A new event increments the indentation level.
+  # * A done event and an error event decrements the indentation level.
+  # * A nil event represents a note, with no potential child-tasks. (No
+  #   indentation change is required.)
+  def get_log_indentation_string(event=nil)
+    if @indent.class != Fixnum # don't indent unless numberical value
+      case event
+      when nil then result = '='
+      when :new then result = '>'
+      when :done then result = '<'
+      when :error then result = '*'
+      else
+        result = '='
+        @debug_out << " =WD= Invalid event Symbol = #{event.inspect}\n" \
+          if WATCHER_DEBUG
+      end
+    else # we got a Fixnum, so use indented log output
+      result = ' ' # plan to place at least one space after the time mark
+      # If WATCHER_DEBUG, we want to use periods instead of spaces to indent
+      space = '.'
+      unless WATCHER_DEBUG
+        # create some run-time protection from bad input
+        # TODO: Validate data when attributes accessors invoked
+        @current_indent = 0 if @current_indent < 0
+        @indent = 3 if @indent < 3
+        space = ' ' # if not debugging Watcher, go ahead and use spaces
+      end
+      
+      #--
+      # If @indent is >= 3, arrows are created at each indent level to show
+      # the parent-child relationship between tasks.
+      # * head refers to the head of a log event arrow, and
+      # * tail refers to the tail of a log event arrow.
+      #++
+      case event
+      when nil
+        # same as :new but do not increment the level at the end
+        @current_indent.times do
+          result += space * (@indent-1)
+        end
+        result += 'I'  # tail
+        result += '=' * (@indent-2)
+        result += '>'  # head
+      when :new
+        # increate indent after make this String
+        @current_indent.times do
+          result += space * (@indent-1)
+        end
+        result += 'N'  # tail
+        result += '-' * (@indent-2)
+        result += '>'  # head
+        @current_indent += 1
+      when :done
+        # decrease indent before make this String
+        @current_indent -= 1
+        @current_indent.times do
+          result += space * (@indent-1)
+        end
+        result += 'C'   # head
+        result += '-' * (@indent-1)
+      when :error
+        # decrease indent before make this String
+        @current_indent -= 1
+        @current_indent.times do
+          result += space * (@indent-1)
+        end
+        result += 'E'   # head
+        result += '-' * (@indent-2)
+      else
+        # invalid event code invoked from within Watcher.monitor
+        @debug_out << " =WD= Invalid event Symbol = #{event.inspect}\n" \
+          if WATCHER_DEBUG
+      end
+    end
+    result
+  end
+  
+  # Get the time String, but protect against if plug-in Proc causes an
+  # Exception.
+  def get_protected_log_time_string
+    begin
+      @time_formatter.call
+    rescue
+      Time.now.utc.to_s + " == WARNING: Time Formatter raised Exception! == "
+    end
+  end
+  
+  # When either #debug or #info is invoked, it ends up passing the
+  # batton to the private #monitor method.
+  # * #monitor first sets up some local variables, including setting up a
+  #   variable to store the effective fail_actions for reasons decribed below,
+  #   then optionally makes a log entry concerning the task you desire to
+  #   execute.  This log entry only takes place if the verbosity level of the
+  #   task is equal to or exceeds the Watcher object's stored verbosity
+  #   minimum level, @verbosity.
+  # * After preparations are complete, Watcher checks whether you sent the
+  #   #debug or #info method a block to execute. If you did not send a block,
+  #   Watcher simply returns control to your code at the point immediately
+  #   following where you invoked Watcher.
+  # * If you did pass a block to execute, Watcher sets up a
+  #   <tt>begin...rescue...end</tt> Exception handling block and invokes your
+  #   block inside that protective environment.
+  # * If code invoked by that block triggers an Exception, Watcher passes
+  #   control to the #protect method, which orchestrates a recovery path based
+  #   on the consumer provided fail_actions Array.  If the #debug or #info
+  #   methods were not given a specific set of actions to perform if an
+  #   Exception occurs, then the Watcher object uses its object instance
+  #   attribute @fail_actions to provide the list of actions to complete.  For
+  #   information how this works, see the documentation for the #protect
+  #   method.
+  def monitor(task,run_level,block_was_given,fail_actions) #:doc:
+    # Watcher debugging facility
+    if WATCHER_DEBUG and WATCHER_DEBUG_FAILACTIONS
+      @debug_out << "fail_actions = #{fail_actions.inspect}\n"
+    end
+    
+    # assume no exception for this task
+    success_flag = true
+    
+    # validate input upon initial invocation, not when handling Exception...
+    # abort task if input parameters are not clean
+    if not task.respond_to?(:to_s)
+      @output << get_protected_log_time_string
+      @output << "WATCHER: the 'task' must be printable!\n"
+      return # abort task
+    elsif not @@verbosity_levels.has_key?(run_level)
+      @output << get_protected_log_time_string + "WATCHER: The given " \
+        + "run_level, #{runlevel.inspect}, is not a member of " \
+        + "Watcher::@@verbosity_levels.  Task = [#{task}]\n"
+        return # abort task
+    else
+      # always validate the requested fail actions by helper method
+      protect(task, fail_actions) # e=nil, therefore just validate
+    end
+    
+    # Watcher debugging facility
+    if WATCHER_DEBUG and WATCHER_DEBUG_LEVELS
+      @debug_out << get_protected_log_time_string \
+        + " =WD= task level = :#{run_level}, " \
+        + "verbosity level = :#{@verbosity}\n"
+    end
+    
+    # log the event if the task run level >= verbosity
+    if @@verbosity_levels[run_level] >= @@verbosity_levels[@verbosity]
+      output = get_protected_log_time_string
+      # if no new block given, then task event = nil, (don't indent)
+      output << get_log_indentation_string(block_was_given ? :new : nil)
+      output << task << "\n"
+      @debug_out << output if WATCHER_DEBUG and WATCHER_DEBUG_OUTPUT
+      @output << output
+    end
+    
+    # okay, preparations complete, if a block was given, do it!
+    if block_was_given # block_given? from #debug or #info
+      begin
+        # Create a Continuation object.  A :retry fail action will come back
+        # to this point in code.  A classic "begin, rescue, retry" does not
+        # work, because the retry would occur from an invoked method, protect.
+        callcc{|@continuation|}
+        yield
+        # Log the event if the task run level is greater or equal to the
+        # verbosity
+        # * The task complete log entry only takes place after your block
+        #   returns.
+        # * If you did not send a task block to complete, Watcher will
+        #   conditionally log the event based on the verbosity level, then
+        #   exit back to your code just after you invoked Watcher.
+        # * PROGRAMMER NOTE:  I moved the code from the ensure block to just
+        #   after the yield code in the begin block.
+        # * The reason for this is that there are really two logical ways
+        #   to complete a task: (1) successfully, and (2) unsuccessfully.
+        #   1. This code represents the path by successful code, while the
+        #      rescue block represents the patch by unsuccessful code.
+        #   2. Because the ensure block is always taking place, a failed block
+        #      of consumer code would log the error, then enter the ensure
+        #      block and log the task complete.  That gives the wrong
+        #      impression.
+        if @@verbosity_levels[run_level] >= @@verbosity_levels[@verbosity]
+          # Only display if user wants logging of compeltion events
+          # * Although we don't show the line when @show_completion is false,
+          #   we must still call #get_log_indentation_string(:done) to adjust
+          #   the @current_indent attribute properly.
+          output << get_protected_log_time_string
+          output << get_log_indentation_string(:done) << task << "\n"
+          if @show_completion
+            @debug_out << output if WATCHER_DEBUG and WATCHER_DEBUG_OUTPUT
+            @output << output
+          end
+        end
+      rescue
+        # catch any Exceptions thrown by the executed block
+        success_flag = protect(task, fail_actions, $!)
+      end
+    end
+    
+    # return whether no exceptions occured
+    success_flag
+  end
+
+  # Iterate through fail_actions parameter for a task, and for each action,
+  # either perform or simply ensure it's a valid action.
+  # * #protect is called by #monitor when your code invokes #debug or #info in
+  #   order to validate the fail_actions parameter.
+  # * #protect is also called by #monitor when the associated code block
+  #   triggers an Exception. It receives an Array of actions to perform,
+  #   <tt>fail_actions</tt>, and executes each one in turn.
+  # * Perhaps the most complex--however reasonable--example would be if you
+  #   wanted to log the event, then invoke some snippet of code to attempt to
+  #   resolve the problem, then retry the block.  This can be done by
+  #   specifying the following fail actions. <b>(Be careful, however, as this
+  #   can easily lead to an infinite loop if the recovery Proc does not
+  #   resolve the cause of the original Exception!)</b>
+  # * This is meant to provide you a bit of flexibility on how to handle
+  #   conditions, however a complex Array of fail_actions may defeat your goal
+  #   of code simplification.
+  def protect(task, fail_actions, e=nil) #:doc:
+    # * If e is nil, then return true if valid group, false or raise
+    #   exception if invalid fail action found.
+    # * If e is an Exception, perform required actions.
+
+    # only increase warning if also performing actions
+    if e != nil
+      if e.kind_of?(Exception)
+        @warnings += 1
+      else
+        err_msg = "invalid exception instance (Watcher.monitor error)"
+        raise ArgumentError.new(err_msg)
+      end
+      @debug_out << "e = #{e.inspect}\n" if WATCHER_DEBUG
+    end
+    
+    if fail_actions.class == Symbol or fail_actions.class == Proc
+      # NOTE: we pass the fail_actions (plural) parameter
+      protect_action(task, fail_actions, e)
+    elsif fail_actions.class == Array
+      fail_actions.each do |fail_action|
+        # NOTE: we pass the fail_action (singular) loop iteration variable
+        protect_action(task, fail_action, e)
+      end
+    else
+      err_msg = "unsupported fail action for task = [#{task}] " \
+        + "(must be Symbol or Array of Symbols and Procs)"
+      raise ArgumentError.new(err_msg)
+    end
+  end
+
+  # Either perform action, or simply validate it's valid
+  def protect_action(task, fail_action, e)
+    # * If e is nil, then validate the action against the possible
+    #   actions.  Raise ArgumentError Exception if invalid action found.
+    # * If e is a kind of Exception, perform required action.
+
+    # only time-stamp if also performing actions
+    if e != nil
+      # create the time stamp and indentation portion of the log entry
+      log_base = get_protected_log_time_string \
+        + get_log_indentation_string(:error)
+      @debug_out << "e = #{e.inspect}\n" if WATCHER_DEBUG
+    end
+
+    if fail_action.class == Proc
+      if e != nil
+        # return result from user-specified code
+        return fail_action.call(e) # send the Exception instance
+      end
+    elsif fail_action.class == Symbol
+      case fail_action
+      when :log
+        if e != nil
+          output = log_base + '*' + task + '*' + ' ==> '
+          output << "#{@fail_symbol} ==> " if @fail_symbol
+          if @merge_newlines != false
+            output << e.message.split(/\n/).join(@merge_newlines)
+          else # no merge, but multiple lines
+            output << e.message
+          end
+          @output << output << "\n"
+        end
+      when :raise
+        if e != nil
+          @errors += 1
+          raise
+        end
+      when :retry # FIXME: this is not well tested
+        @continuation.call if e != nil
+      else
+        err_msg = "unsupported fail action Symbol for task = [#{task}] " \
+          + "(must be one of [:log, :raise, :retry])"
+        raise ArgumentError.new(err_msg)
+      end
+    else # only Symbols and Procs can be designated fail actions
+      raise ArgumentError.new("invalid fail action (Watcher.protect error)")
+    end
+  end
+  
+  # Set to true when Watcher should execute itself in debugging mode.
+  WATCHER_DEBUG=false
+
+  # Name of file that Watcher creates for its debugging output.
+  WATCHER_DEBUG_OUTPUT_FILENAME='watcher-debug.log'
+
+  # Set to true when debugging Watcher instance attribute settings.
+  WATCHER_DEBUG_ATTRIBUTES=false
+  
+  # Set to true when debugging Watcher handling of fail actions.
+  WATCHER_DEBUG_FAILACTIONS=false
+
+  # Set to true when debugging Watcher verbosity levels.
+  WATCHER_DEBUG_LEVELS=false
+
+  # Set to true when debugging Watcher.monitor.
+  WATCHER_DEBUG_MONITOR=false
+
+  # Set to true when debugging Watcher's log strings.
+  WATCHER_DEBUG_OUTPUT=false
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/watcher.rb'}"
+puts "Loading watcher gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)