consoleappsupport 0.5.0

data/History.txt

@@ -0,0 +1,13 @@
+=== 0.5.0 / 2009-06-08
+
+* Initial public release
+
+  * Determines configuration options for a program by parsing specially-formatted
+    comments in the main source file, similarly to RDoc.
+  * Loads values for these configuration options by parsing the command line.
+  * Loads further values from a run-time config file. As usual, command-line
+    options override config file options, which override defaults.
+  * Provides a Log4r object with the default configuration, pointed to STDOUT.
+  * Automatically loads a Logr4 config file, if config option "--log4r-file" is
+    defined and enabled.
+  * Displays RDoc usage message if config option "--help" is defined and enabled.

data/Manifest.txt

@@ -0,0 +1,13 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+examples/apache_log_to_csv.conf
+examples/console_app_example.conf
+examples/console_app_example.rb
+examples/convert_logs_to_csv.rb
+examples/example_log4r.xml
+lib/ConsoleAppSupport.rb
+lib/ConsoleAppHelper.rb
+lib/ConsoleAppMixin.rb
+test/test_consoleappsupport.rb

data/README.txt

@@ -0,0 +1,69 @@
+= consoleappsupport
+http://rubyforge.org/projects/consolesupport/
+
+== DESCRIPTION:
+The ConsoleAppSupport module provides some commonly-desired behavior
+for command-line programs. Its primary audience is Ruby coders 
+who need to frequently and quickly write special-purpose scripts
+that are nevertheless flexible and self-documenting.
+
+== FEATURES:
+This module currently provides the following configuration services for 
+command-line applications:
+* Determines configuration options for a program by parsing specially-formatted
+  comments in the main source file, similarly to RDoc.
+* Loads values for these configuration options by parsing the command line.
+* Loads further values from a run-time config file. As usual, command-line
+  options override config file options, which override defaults.
+
+The module also provides the following logging services for command-line
+applications:
+* Provides a Log4r object with the default configuration, pointed to STDOUT.
+* Automatically loads a Logr4 config file, if config option "--log4r-file" is 
+  defined and enabled.
+* Displays RDoc usage message if config option "--help" is defined and enabled.
+
+== SYNOPSIS:
+1. 'require consoleappsupport' from somewhere in your code.
+2. Define your program's configuration options in the initial comment block.
+   (see below, and examples/console_app_example.rb for examples)
+3. 'include ConsoleAppSupport::ConsoleAppMixin' in your main application class.
+4. Call super in your program's initialize method.
+5. Use @opts[:option_name] to access the final configuration.
+6. Use @log.[debug,info,etc.] to send log messages.
+7. Call read_configuration_files at any time to reload the both the application
+   config file and the Log4r configuration file.
+
+== REQUIREMENTS:
+log4j
+log4r/configurator
+optparse 
+rdoc/usage
+ostruct
+
+== INSTALL:
+sudo gem consoleappsupport
+
+== LICENSE:
+(The MIT License)
+
+Copyright (c) 2009 FIX
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,9 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.spec 'consoleappsupport' do
+  self.rubyforge_name = 'consolesupport' # if different than 'consoleappsupport'
+  self.developer('benton', 'bentonroberts@me.com')
+end

data/examples/apache_log_to_csv.conf

@@ -0,0 +1,6 @@
+# Config file for convert_logs_to_csv.rb
+# Use the format: key = value
+# This pattern and field list are used for Apache "combined" log format
+# See http://httpd.apache.org/docs/2.0/logs.html#combined
+log-fields =  client ip, identd, user, date, time, time zone, method, request, protocol, response code, bytes returned, referrer, user agent
+log-pattern = ^(\S+)\s+(\S+)\s+(\S+)\s+\[([\w\/]+):([\d:]+)\s+(\S+)\]\s+"(\S+)\s+(\S+)\s+(\S+)"\s+(\S+)\s+(\S+)\s+"([^"]+)"\s+"([^"]+)"

data/examples/console_app_example.conf

@@ -0,0 +1,4 @@
+# Use the format: key = value
+#log_level = DEBUG
+repeat-output = 2
+ 

data/examples/console_app_example.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby 
+
+# == Synopsis 
+#   Example application demonstrating the use of the ConsoleAppMixin.
+#   Prints all configuration info, then prints the command-line arguments.
+#
+# == Examples
+#   console_app_example.rb -h
+#   console_app_example.rb Show me the arguments
+#   console_app_example.rb -n 5 Show me the arguments
+#   console_app_example.rb -l debug Show me the arguments
+#
+# == Usage 
+#   console_app_example.rb [options] argument1 arg2 etc...
+#
+# == Options (all options can be put into the config file)
+#   -n, --repeat-output [INTEGER]   Number of times to echo back the arguments. default = 1
+#   -c, --config-file [FILE]        Use config file [FILE]. default = console_app_example.conf 
+#   -l, --log-level [LEVEL]   Sets Log4r level for console output. default = INFO
+#   -r, --log4r-file [FILE]   Optional Log4r config file. default = example_log4r.xml
+#   -h, --help                Displays help message
+#
+# == Author
+#   Benton Roberts
+
+require "consoleappsupport"
+
+class ExampleConsoleApp
+  include ConsoleAppSupport::ConsoleAppMixin
+
+  def initialize
+    super 
+  end
+
+  def run
+    @log.info "Application options: "+ @app_options.inspect
+    @log.info "Application defaults: "+ @default_options.inspect
+    @log.info "Config file options: "+ @configfile_options.inspect
+    @log.info "Command-line options: "+ @commandline_options.inspect
+    @log.info "Final run-time options: "+ @opts.inspect
+    1.upto(@opts[:repeat_output]) { @log.info ARGV.join(' ') }
+  end
+
+end
+
+myApp = ExampleConsoleApp.new
+myApp.run

data/examples/convert_logs_to_csv.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby 
+
+# == Synopsis
+#   An example application for the ConsoleAppSupport package.
+#   This program reads log lines from STDIN,
+#   and writes them to STDOUT as comma-separated-value lines.
+#   Log messages are written to STDERR.
+#
+# == Examples
+#   cat *.log | convert_logs_to_csv.rb -c apache_log_to_csv.conf > log_data.csv
+#   convert_syslogs_to_csv.rb -h
+#
+# == Usage 
+#   cat [log files] | convert_logs_to_csv.rb [options] > [output file.csv]
+#
+# == Options (all options can be put into the config file)
+#   -p, --log-pattern [REGEX]   Regular expression for matching log lines.
+#   -f, --log-fields [LIST]     A list of field names to assign to the parenthesized log-pattern matches.
+#   -c, --config-file [FILE]    Use config file [FILE], default = apache_log_to_csv.conf 
+#   -l, --log-level [LEVEL]     Sets log level to DEBUG, INFO, WARN, ERROR or FATAL. default = INFO
+#   -h, --help                  Displays help message
+#
+# == Author
+#   Benton Roberts
+
+# First, load console app support, and log messages to STDERR
+#require "#{File.dirname(__FILE__)}/../lib/ConsoleAppHelper.rb"
+require "consoleappsupport"
+helper = ConsoleAppSupport::ConsoleAppHelper.new('converter', true)
+log = helper.log
+log.outputters = Log4r::Outputter.stderr
+# First, parse the command-line and read config the file
+opts = helper.read_configuration_files
+
+# Turn the "log_fields" run-time option into an array
+log_fields = opts[:log_fields].split(',').map { |field| field.strip }
+log.info "Searching for fields: #{log_fields.join ','}"
+# Turn the "log_pattern" run-time option into an Regular Expression object
+pattern = Regexp.new(opts[:log_pattern], Regexp::EXTENDED)
+log.debug "Using pattern: #{pattern}"
+########## BEGIN OUTPUT
+puts log_fields.join(',')  # Print the CSV header
+# Now read through each line of standard input
+lines = 0
+while(line = STDIN.gets)
+  line.chomp
+  if (matches = pattern.match(line)) then
+    values = matches.to_a     # Convert matches to array
+    values = values[1..values.size]   # First element contains entire match
+    values = values.map do |value|    # Escape values as necessary...
+      if value.include?('"') or value.include?(',') then
+        value.gsub!('"','\\"')        # Escape quotation marks
+        value = "\"#{value}\""        # And quote the whole thing
+      end
+      value
+    end
+    puts values.join(',')     # Print the values
+    lines += 1
+  else
+    log.warn "Unmatched line: #{line}"
+  end
+end
+# Report on how we did
+log.info "Done. Wrote #{lines} CSV data records."

data/examples/example_log4r.xml

@@ -0,0 +1,21 @@
+<!--	Log Configuration -->
+<log4r_config>
+	<pre_config>
+		<custom_levels>DEBUG, INFO, WARN, ERROR, FATAL</custom_levels>
+		<global level="ALL"/>
+	</pre_config>
+
+	<!-- Outputters -->
+	<outputter name="console" type="StdoutOutputter" level="DEBUG" >
+		<formatter type="Log4r::PatternFormatter">
+			<pattern>%5l: %M</pattern>
+		</formatter>
+	</outputter>
+
+	<!-- Loggers -->
+	<logger name="ExampleConsoleApp"
+		level="ALL" additive="false" trace="true">
+		<outputter>console</outputter>
+	</logger>
+	
+</log4r_config>

data/lib/ConsoleAppHelper.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby 
+
+# == Synopsis 
+#   Helper class for the ConsoleAppSupport package.
+# 
+#   The ConsoleAppHelper provides the same services as 
+#   ConsoleAppSupport::ConsoleAppMixin, but without affecting 
+#   the local namespace.
+#
+# == Examples
+#    (see examples/convert_logs_to_csv.rb)
+#
+# == Usage 
+#   * 'require consoleappsupport' from somewhere in your code.
+#   * Define your program's configuration options in the initial comment block.
+#     (see examples/convert_logs_to_csv.rb for examples)
+#   * Create a ConsoleAppSupport::ConsoleAppHelper in your program's initialize method.
+#   * Use helper.opts[:option_name] to access the final configuration.
+#   * Use helper.log.[debug,info,etc.] to send log messages.
+#   * Call helper.read_configuration_files at any time to reload the appliation and
+#     Log4r configuration files.
+
+require "#{File.dirname(__FILE__)}/../lib/ConsoleAppMixin.rb"
+    
+module ConsoleAppSupport
+  class ConsoleAppHelper
+    include ConsoleAppSupport::ConsoleAppMixin 
+    def initialize(*args)
+      super *args
+    end    
+  end
+end

data/lib/ConsoleAppMixin.rb

@@ -0,0 +1,325 @@
+#!/usr/bin/env ruby 
+
+# == Synopsis 
+#   Main module for the ConsoleAppSupport package.
+#
+#   The ConsoleAppMixin provides configuration and logging
+#   behavior for command-line applications:
+#   * Determines configuration options for a program by parsing the comments in the main source file.
+#   * Loads values for these configuration options by parsing a configuration file at run-time.
+#   * Overrides the configuration file values with any values passed on the command-line.
+#   * Provides a Log4r object with the default configuration, pointed to STDOUT.
+#   * Automatically loads a Logr4 config file, if config option "--log4r-file" is defined and enabled.
+#   * Displays RDoc usage message if config option "--help" is defined and enabled.
+#
+# == Examples
+#    (see examples/console_app_example.rb)
+#
+# == Usage 
+#   * 'require consoleappsupport' from somewhere in your code.
+#   * Define your program's configuration options in the initial comment block.
+#     (see examples/console_app_example.rb for examples)
+#   * 'include ConsoleAppSupport::ConsoleAppMixin' in your main application class.
+#   * Call super in your program's initialize method.
+#   * Use @opts[:option_name] to access the final configuration.
+#   * Use @log.[debug,info,etc.] to send log messages.
+#   * Call read_configuration_files at any time to reload the appliation and
+#     Log4r configuration files.
+
+module ConsoleAppSupport
+  
+  module ConsoleAppMixin
+    require 'log4r'
+    require 'log4r/configurator'
+    require 'optparse' 
+    require 'rdoc/usage'
+    require 'ostruct'
+
+    # An array of symbols representing the names of the 
+    # application's possible configuration options.
+    attr_reader :app_options
+    # Hash containing the final configuration values, indexed by app_options
+    attr_reader :opts
+    # Hash of containing the default configuration values, indexed by app_options
+    attr_reader :default_options
+    # Hash containing the config file values, indexed by app_options
+    attr_reader :configfile_options
+    # Hash containing the command-line values, indexed by app_options
+    attr_reader :commandline_options
+    
+    # A Log4r logger, initially pointed to STDOUT at level INITIAL_LOG_LEVEL
+    attr_reader :log                  
+    
+    # Regexp used to read application options from the main source file
+    OPTIONS_LINE_EXPRESSION = %r{^\s*#\s*-([\w-]+)\s*,\s*--([\w-]+)\s*(\S.*)$}
+    # Regexp used to determine the Ruby type of each application option
+    OPTION_VALUE_EXPRESSION = %r{^\s*\[(\w+)\]}
+    # Regexp used to determine the default value of each application option
+    DEFAULT_VALUE_EXPRESSION = %r{default[^=]*=\s*(.*\S)\s*$}i
+
+    # Predefined names for application options
+    # that trigger this module's specialized behavior:
+    # * :help             - Prints usage and exits
+    # * :config_file      - Selects a config file for more options
+    # * :log_level        - Sets the STDOUT logging level
+    # * :log4r_file       - Loads a Log4r config file
+    SPECIAL_OPTIONS = {
+      :help         => "help",
+      :config_file  => "config_file",
+      :log_level    => "log_level",
+      :log4r_file   => "log4r_file",
+    }
+    
+    # Logging level during module initilization.
+    # Redefine this to DEBUG before calling super if you
+    # need to trace parsing of the main application source file.
+    INITIAL_LOG_LEVEL = 'INFO'
+
+    # Parses the top-level source file for application configuration options.
+    # Unless skip_config is true, read_configuration_files is then called.
+    def initialize(logger_name = self.class.name, skip_config = false)
+      @app_options = []
+      @opts = @configfile_options = {}
+      initialize_logging logger_name
+      populate_app_options
+      setup_default_options
+      parse_command_line
+      read_configuration_files unless skip_config
+    end
+
+    # Reads the application config file for configuration options, then
+    # loads the Log4r config file (as directed by :log4r_file option).
+    # Returns @opts, the final runtime_options hash.
+    def read_configuration_files
+      config_file = get_config_file_name
+      load_config_file(config_file) if config_file_exists? config_file
+      @log.debug "Config file options loaded: #{@configfile_options.inspect}"
+      @opts = @default_options.merge(@configfile_options.merge(@commandline_options))
+      @log.debug "Final run-time options: #{@opts.inspect}"
+      load_log4r_config_file
+      @opts
+    end  
+
+    #########################################################
+    private # methods
+
+    def initialize_logging(logger_name)
+      @log = Log4r::Logger.new logger_name 
+      @log.outputters = Log4r::Outputter.stdout
+      @log.level = Log4r::INFO
+      @opts = { SPECIAL_OPTIONS[:log_level] => @log.level }
+      set_log_level INITIAL_LOG_LEVEL
+    end
+
+    # Populates the instance variable @_app_options, based on the 
+    # comments in the main application file
+    def populate_app_options
+      @_app_options = {}
+      @log.debug "Reading comments from main application file #{$0}"
+      main_file = File.new($0, "r") 
+      while (line = main_file.gets)
+        if (matches = OPTIONS_LINE_EXPRESSION.match line.chomp) then
+          switch, param, description = matches.captures
+          @log.debug "Found application parameter #{param} with switch #{switch}"
+          new_app_option = {:switch => switch, :help => description}
+          if (OPTION_VALUE_EXPRESSION.match description) then
+            @log.debug "This parameter accepts a value of type #{$1}"
+            new_app_option[:type] = $1
+            if (DEFAULT_VALUE_EXPRESSION.match description) then
+              @log.debug "This parameter defaults to '#{$1}'"
+              new_app_option[:default] = convert_string($1, new_app_option[:type])
+            end
+          end
+          @_app_options[param] = new_app_option
+        end
+      end
+      main_file.close
+      @app_options = @_app_options.keys.sort.map { |option| option.gsub('-','_').intern}
+      @log.debug "Application options: #{@app_options.inspect}"
+    end
+
+    # Creates a hash of default option values
+    def setup_default_options
+      @default_options = {}
+      @_app_options.each do |parameter, details|
+        switch = "-#{details[:switch]}"
+        param_string = "--#{parameter}"
+        param_string += " [#{details[:type]}]" if details[:type]
+        if details[:default] then
+          param_key = parameter.gsub('-','_')
+          value = convert_string(details[:default], details[:type])
+          # TODO: convert value to desired type
+          @default_options[param_key.intern] = value
+          set_log_level(value) if param_key == SPECIAL_OPTIONS[:log_level]
+        end
+      end
+      @log.debug "Application defaults: #{@default_options.inspect}"
+    end
+
+    # Populates the instance variable @cmdline_opts based on the 
+    # command-line supplied at run-time
+    def parse_command_line
+      @commandline_options = {}
+      opts = OptionParser.new 
+      @_app_options.each do |parameter, details|
+        switch = "-#{details[:switch]}"
+        param_string = "--#{parameter}"
+        param_string += " [#{details[:type]}]" if details[:type] 
+        opts.on(switch, param_string) do |value|
+          set_cmdline_opt(parameter, value, details[:type])
+        end
+      end
+      begin
+        opts.parse!(ARGV)
+      rescue => e
+        @log.fatal "Error parsing command-line parameters: #{e}"
+        exit 1
+      end
+      @log.debug "Command-line parameters passed: #{@commandline_options.inspect}"
+    end
+
+    # Stores an individual command-line option in @cmdline_opts
+    def set_cmdline_opt(parameter, value, type = nil)
+      value = convert_string(value, type) # Convert to type
+      param_key = parameter.gsub('-','_')
+      @commandline_options[param_key.intern] = value
+      # Handle special options...
+      set_log_level(value) if param_key == SPECIAL_OPTIONS[:log_level]
+      output_help if param_key == SPECIAL_OPTIONS[:help]
+      @log.debug "Found command-line parameter: #{parameter} (#{value})"
+    end
+
+    # Returns the final path to the config file 
+    def get_config_file_name
+      cfg_path = nil
+      config_param = SPECIAL_OPTIONS[:config_file]
+      param_key = config_param.gsub('-','_').intern
+      if @commandline_options.has_key? param_key then
+        cfg_path = @commandline_options[param_key] 
+      else
+        cfg_path = @default_options[param_key] 
+      end
+      cfg_path
+    end
+
+    # Returns true if cfg_path exists in the filesystem, false or nil otherwise
+    def config_file_exists?(cfg_path)
+      file_exists = nil
+      if cfg_path then
+        @log.debug "Checking for config file #{cfg_path}..."
+        if File.exists? cfg_path then
+          file_exists = true
+        else
+          file_exists = false
+          error_msg = "Configuration file #{cfg_path} does not exist."
+          param_key = SPECIAL_OPTIONS[:config_file].gsub('-','_').intern
+          if @commandline_options[param_key] then
+            @log.fatal "#{error_msg} Terminating."
+            exit 2
+          else
+            @log.info "#{error_msg} Skipping..."
+          end
+        end
+      end
+      file_exists
+    end
+
+    # Parses the file at cfg_path, and populates @configfile_options with results
+    def load_config_file(cfg_path)
+      # Open and read in config file
+      @log.info "Loading configuration file #{cfg_path}..."
+      cfg_file = File.new(cfg_path,'r')
+      begin
+        while (line = cfg_file.gets)
+          if line =~ /^\s*([^\s#]+)\s*=\s*(.+)$/
+            key = $1 ; value = $2
+            @log.debug "Read config file parameter '#{key}' with value: #{value}"
+            if not @app_options.include? key.gsub('-','_').intern then
+              @log.fatal "Unrecognized application option '#{key}'"
+              exit 4
+            end
+            value = convert_string(value, @_app_options[key][:type])
+            @configfile_options[key.gsub('-','_').intern] = value
+            # Handle special options
+            set_log_level value if key.gsub('-','_') == SPECIAL_OPTIONS[:log_level]
+          end
+        end
+      rescue => error
+        @log.fatal "Could not read config file #{cfg_file}: #{error}"
+        exit 3
+      ensure
+        cfg_file.close
+      end
+    end
+
+    # Loads the Log4r config file, if it exists. 
+    # Otherwise, exits the program if a log4r file was specified by the user
+    def load_log4r_config_file
+      log4r_key = SPECIAL_OPTIONS[:log4r_file].gsub('-','_').intern
+      if cfg_path = @opts[log4r_key]
+        if not File.exists? cfg_path then
+          error_msg = "Log4r configuration file #{cfg_path} does not exist."
+          if cfg_path != @default_options[log4r_key] then
+            @log.fatal "#{error_msg} Terminating."
+            exit 2
+          else
+            @log.info "#{error_msg} Skipping..."
+          end
+        else
+          @log.info "Loading Log4r config file #{cfg_path}..."
+          log_name = @log.name
+          Log4r::Configurator.load_xml_file cfg_path
+          @log = Log4r::Logger[log_name]
+        end
+      end
+    end
+    
+    #########################################################
+    # Utility methods
+
+    def set_log_level(log_level)
+      log_level.upcase!
+      log4r_levels = { 
+        "DEBUG" => Log4r::DEBUG,
+        "INFO" => Log4r::INFO,
+        "WARN" => Log4r::WARN,
+        "ERROR" => Log4r::ERROR,
+        "FATAL" => Log4r::FATAL 
+      }
+      current_level = @opts[SPECIAL_OPTIONS[:log_level]]
+      desired_level = log4r_levels[log_level]
+      if (! desired_level) then 
+        @log.warn "Undefinded log level '#{log_level}' - keeping #{current_level}"
+      else
+        @opts[SPECIAL_OPTIONS[:log_level]] = log_level
+        if @log.level != desired_level then
+          @log.info "Changing application logging level to #{log_level}"
+          @log.level = desired_level
+          @opts[SPECIAL_OPTIONS[:log_level]] = @log.level
+        end
+      end
+    end
+    
+    # Converts a string to a numeric of a specified type
+    def convert_string(value, type)
+      if type then
+        case type.downcase 
+        when 'integer'
+          value = value.to_i
+        when 'float'
+          value = value.to_f
+        end
+      end
+      value
+    end
+
+    def output_help
+      RDoc::usage() #exits app
+    end
+
+    def output_usage
+      RDoc::usage('usage') # gets usage from top-level file comments
+    end
+
+  end
+end

data/lib/ConsoleAppSupport.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby 
+
+# == Synopsis 
+#   Wrapper file for the ConsoleAppSupport package.
+#   All of this package's functionality is currently in ConsoleAppSupport::ConsoleAppMixin
+#   See that module's documentation for usage.
+
+module ConsoleAppSupport
+  VERSION = '0.5.0'
+end
+
+require "#{File.dirname(__FILE__)}/ConsoleAppHelper.rb"

data/test/test_consoleappsupport.rb

@@ -0,0 +1,8 @@
+require "test/unit"
+#require "consoleappsupport"
+
+class TestConsoleappsupport < Test::Unit::TestCase
+  def test_sanity
+    assert(true, "Not yet implemented")
+  end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: consoleappsupport
+version: !ruby/object:Gem::Version 
+  version: 0.5.0
+platform: ruby
+authors: 
+- benton
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-08 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+    version: 
+description: |-
+  The ConsoleAppSupport module provides some commonly-desired behavior
+  for command-line programs. Its primary audience is Ruby coders 
+  who need to frequently and quickly write special-purpose scripts
+  that are nevertheless flexible and self-documenting.
+email: 
+- bentonroberts@me.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- examples/apache_log_to_csv.conf
+- examples/console_app_example.conf
+- examples/console_app_example.rb
+- examples/convert_logs_to_csv.rb
+- examples/example_log4r.xml
+- lib/ConsoleAppSupport.rb
+- lib/ConsoleAppHelper.rb
+- lib/ConsoleAppMixin.rb
+- test/test_consoleappsupport.rb
+has_rdoc: true
+homepage: http://rubyforge.org/projects/consolesupport/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: consolesupport
+rubygems_version: 1.3.4
+signing_key: 
+specification_version: 3
+summary: The ConsoleAppSupport module provides some commonly-desired behavior for command-line programs
+test_files: 
+- test/test_consoleappsupport.rb