simpleconsole 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,9 @@
+The MIT License
+
+Copyright (c) 2006 Hugh Bien
+
+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/bin/execute

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby -w
+require File.dirname(__FILE__) + "/../lib/init.rb"
+
+class TController < SimpleConsole::Controller
+  params :string => [:n => :name]
+  before_filter :check_for_invalid
+
+  def say_hi
+    puts "hi"
+  end
+
+  def show_id
+    @id = params[:id]
+  end
+
+  def show_name
+    @name = params[:name]
+  end
+
+  def show_title
+    @title = params[:title]
+  end
+
+  def method_missing(action)
+    puts "Unkown action: " + action.to_s
+  end
+
+  private
+  def check_for_invalid
+    if invalid_params?
+      print "Invalid param(s): "
+      puts invalid_params.join(", ")
+      exit
+    end
+  end
+
+  def finale
+    puts "finale!"
+  end
+end
+
+class TView < SimpleConsole::View
+
+  def show_id
+    puts "The value of id is #{@id}"
+  end
+
+  def show_name
+    puts "The value of name is #{@name}"
+  end
+
+  def show_title
+    puts "The value of title is #{@title}"
+  end
+
+end
+
+begin
+  SimpleConsole::Application.run(ARGV, TController, TView)
+rescue Exception => error
+  puts error
+end

data/bin/files/Rakefile

@@ -0,0 +1,101 @@
+require "rake/clean"
+require "rubygems"
+Gem::manage_gems
+require "rake/gempackagetask"
+
+CLEAN.include("doc")
+SRC = FileList['lib/*']
+
+desc "Creates documentation for the project"
+task :doc do
+  sh "rdoc README MIT-LICENSE lib/* --main README"
+end
+
+desc "Runs all unit tests"
+task :test do
+  Dir.glob("test/test_*.rb").each do |file|
+    require file
+  end
+end
+
+# needs some cleaning?
+desc "Shows the total lines and LOC status"
+task :stats do
+  total_lines = 0
+  total_codelines = 0
+  files = Hash.new
+
+  # Start with the library files
+  Dir.glob("lib/*").each do |file_name| 
+    lines = 0; codelines = 0
+
+    next unless file_name =~ /.*rb/
+    
+    file = File.open(file_name)
+
+    while line = file.gets
+      lines += 1
+      next if line =~ /^\s*$/
+      next if line =~ /^\s*#/
+      codelines += 1
+    end
+
+    files[File.basename(file_name)] = [lines, codelines]
+    total_lines += lines
+    total_codelines += codelines
+  end 
+
+  puts "+-----------------------------------+--------+--------+"
+  puts "| Library File                      | Lines  | LOC    |"
+  puts "+-----------------------------------+--------+--------+"
+  files.each do |file_name, array| 
+    print "| " + file_name + (" "*(34 - file_name.size)) + "|" 
+    print " #{array[0]}" + (" "*(7 - array[0].to_s.size)) + "|"
+    puts " #{array[1]}" + (" "*(7 - array[1].to_s.size)) + "|"
+  end
+  puts "+-----------------------------------+--------+--------+"
+  print "| Total                             |"
+  print " #{total_lines}" + (" "*(7 - total_lines.to_s.size)) + "|"
+  puts " #{total_codelines}" + (" "*(7 - total_codelines.to_s.size)) + "|"
+  puts "+-----------------------------------+--------+--------+"
+
+  # Now do the test files
+  total_lines = 0; total_codelines = 0; files = Hash.new
+  Dir.glob("test/test_*").each do |file_name| 
+    lines = 0; codelines = 0
+
+    next unless file_name =~ /.*rb/
+    
+    file = File.open(file_name)
+
+    while line = file.gets
+      lines += 1
+      next if line =~ /^\s*$/
+      next if line =~ /^\s*#/
+      codelines += 1
+    end
+
+    files[File.basename(file_name)] = [lines, codelines]
+    total_lines += lines
+    total_codelines += codelines
+  end 
+
+  puts "+-----------------------------------+--------+--------+"
+  puts "| Test File                         | Lines  | LOC    |"
+  puts "+-----------------------------------+--------+--------+"
+  files.each do |file_name, array| 
+    print "| " + file_name + (" "*(34 - file_name.size)) + "|" 
+    print " #{array[0]}" + (" "*(7 - array[0].to_s.size)) + "|"
+    puts " #{array[1]}" + (" "*(7 - array[1].to_s.size)) + "|"
+  end
+  puts "+-----------------------------------+--------+--------+"
+  print "| Total                             |"
+  print " #{total_lines}" + (" "*(7 - total_lines.to_s.size)) + "|"
+  puts " #{total_codelines}" + (" "*(7 - total_codelines.to_s.size)) + "|"
+  puts "+-----------------------------------+--------+--------+"
+end
+
+desc "Shows a quick coverage of tests."
+task :rcov do 
+  sh "rcov -T test/test_*.rb"
+end

data/bin/files/application.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby -w
+require "rubygems"
+require "simpleconsole"
+# require File.dirname(__FILE__) + "/../"
+
+SimpleConsole::Application.run(ARGV, _Controller_, _View_)

data/bin/files/controller.rb

@@ -0,0 +1,5 @@
+require "rubygems"
+require "simpleconsole"
+
+class _Controller_ < SimpleConsole::Controller
+end

data/bin/files/single.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby -w
+require "rubygems"
+require "simpleconsole"
+# require File.dirname(__FILE__) + "/../"
+
+class _Controller_ < SimpleConsole::Controller
+end
+
+class _View_ < SimpleConsole::View
+end
+
+SimpleConsole::Application.run(ARGV, _Controller_, _View_)

data/bin/files/view.rb

@@ -0,0 +1,5 @@
+require "rubygems"
+require "simpleconsole"
+
+class _View_ < SimpleConsole::View
+end

data/bin/simcon

@@ -0,0 +1,160 @@
+#!/usr/bin/env ruby -w
+# require File.dirname(__FILE__) + "/../lib/init.rb"
+require "rubygems"
+require "simpleconsole"
+
+class Controller < SimpleConsole::Controller
+  params :string => {:c => :controller, :v => :view, :f => :file},
+         :bool => {:h => :help}
+  before_filter :check_params
+  before_filter :set_file, :only => [:application, :controller, :single, :view]
+  after_filter :put_file, :only => [:application, :controller, :single, :view]
+
+  def rakefile
+    @filename = "Rakefile"
+    read_file(@filename)
+    put_file(@filename)
+  end
+
+  def default
+    redirect_to :action => :help
+  end
+
+  def help
+    generators = [:application, :controller, :rakefile, :single, :view]
+    unless params[:id].nil?
+      redirect_to(:action => ("help_" + params[:id]).to_sym) if generators.include?(params[:id].to_sym)
+      render :action => :unknown_help
+    else
+      render :action => :help
+    end
+  end
+
+  def method_missing(method = "method_missing")
+    puts "Unknown action - #{method.to_s}."
+    puts "Try using 'simcon help' for usage info."
+  end
+
+  private
+  def set_file
+    if params.has_key?(:file)
+      @filename = params[:file]
+    else
+      @filename = nil
+    end
+
+    read_file
+  end
+
+  def read_file(filename = params[:action].to_s + ".rb")
+    begin 
+      file = File.open(File.dirname(__FILE__) + "/files/" + filename)
+      @file_contents = file.read
+      file.close
+    rescue Exception => error
+      puts "Error when trying to open the file '#{filename}' for reading: "
+            + error.to_s
+    end
+
+    controller = params[:controller] || "Controller"
+    view = params[:view] || "View"
+    substitute_content(/_Controller_/ => controller, /_View_/ => view)
+  end
+
+  def put_file(filename = @filename)
+    if @filename
+      begin
+        File.open(filename, "w") do |file|
+          file.puts @file_contents
+        end
+      rescue Exception => error
+        puts "Error when trying to open the file '#{filename}' for writing: " 
+              + error.to_s
+      end
+    else
+      puts @file_contents
+    end
+
+    render(:action => :file_generated)
+  end
+
+  def check_params
+    if params.has_key?(:help)
+      render :action => :help
+    end
+
+    if invalid_params?
+      puts "Unkown option(s): #{invalid_params.join(", ")}"
+      puts "Try using 'simcon help' for usage info."
+      exit
+    end
+  end
+
+  def substitute_content(rules)
+    rules.each do |regexp, replacement|
+      @file_contents.gsub!(regexp, replacement)
+    end
+  end
+end
+
+class View < SimpleConsole::View
+  def help
+    puts "Usage: simcon [generator] [--file output_file] [--options]"
+    puts ""
+    puts "Available generators and their usage:"
+    puts "  application [--file output_file] [-c controller_name | -v view_name]"
+    puts "  controller [--file output_file] [-c controller_name]"
+    puts "  rakefile"
+    puts "  single [--file output_file] [-c controller_name | -v view_name]"
+    puts "  view [--file output_file] [-v view_name]"
+    puts ""
+    puts "The generators will create a new file given by the '-f output_file' argument.  If no '--file' was given, it will output to STDOUT.  Try 'gen help [generator]' for more info about each generator."
+    puts ""
+    puts "Available options:"
+    puts "  -f | --file FILENAME"
+    puts "  -c | --controller CONTROLLER"
+    puts "  -v | --view VIEW"
+  end
+
+  def file_generated
+    puts "The file '#{@filename}' was generated." if @filename
+  end
+
+  def help_application
+    puts "Usage simcon application [-f output_file] [-c controller_name | -v view_name]"
+    puts ""
+    puts "Generates the script that will run an application.  The Controller/View class names should be replaced and any files should be required within the script."
+  end
+
+  def help_controller
+    puts "Usage simcon controller [-f output_file] [-c controller_name]"
+    puts ""
+    puts "Generates the Controller class for an application."
+  end
+
+  def help_single
+    puts "Usage simcon single [-f output_file] [-c controller_name | -v view_name]"
+    puts ""
+    puts "Generates an entire application within a single script, including the Controller/View classes and the Application.run statement."
+  end
+
+  def help_view
+    puts "Usage simcon view [-f output_file] [-v view_name]"
+    puts ""
+    puts "Generates the View class for an application."
+  end
+
+  def help_rakefile
+    puts "Usage: simcon rakefile"
+    puts ""
+    puts "Will generate a default Rakefile in the current directory."
+    puts "Some tasks include: rdoc, rcov, tests, stats, package, and install."
+  end
+
+  def unknown_help
+    puts "Unknown action - #{params[:id]}."
+    help
+  end
+end
+
+SimpleConsole::Application.run(ARGV, Controller, View)

data/lib/application.rb

@@ -0,0 +1,59 @@
+# Runs the application with the given controller and view.
+#
+# == Sample Usage
+# Inside the script myapp:
+#
+#   #!/usr/bin/env ruby -w
+#   require "rubygems"
+#   require "simpleconsole"
+#   require "your_files_with_controller_and_view.rb"
+#
+#   Application.run(ARGV, ControllerClassConstant, ViewClassConstant)
+#   # .. the ViewClassConstant is optional, so run(ARGV, ControllerClassConstant) is valid
+#
+# From the command line:
+#
+#   myapp [action] [id] [options]
+#   myapp action id --key value
+#
+# * action - this will be implemented as a method in the controller and/or view
+# * id - this is accessible in the controller/view as params[:id]
+# * options - will become available through the params hash.  So "--key value" will be params[:key] = value.
+#
+# == Routing Rules
+# * Usually, ARGV is passed to argv for parsing and execution.
+# * ARGV[0] is taken to be the _action_ to execute
+# * In the case that ARGV[0] does not exist, then the controller and view are called with the method 'default'.
+# * If controller_klass implements _action_ as a method, it is executed.
+# * If view_klass implements _action_ as a method, it is executed after the controller.
+# * If there is no view_klass, no _action_ is taken for the view.
+# * If the _action_ only exists in the controller_klass or view_klass, only that single _action_ is executed and no errors are raised.
+# * If no _action_ exists in the controller_klass or view_klass, controller_klass's _method_missing_ is called and the view is ignored.
+class SimpleConsole::Application
+
+  # This is the method to call to run your program from the top-level script.
+  # Check out the rdoc on SimpleConsole::Application for usage.
+  def self.run(argv, controller_klass, view_klass = nil)
+    @@control = controller_klass.new
+    @@view = view_klass ? view_klass.new(@@control) : nil
+    @@control.set_params(argv)
+    @@control.set_action(argv[0] || :default)
+
+    @@control.execute_action
+    @@view.render_action unless @@view.nil?
+
+    @@control.method_missing(@@control.params[:action]) if !control_implements? && !view_implements?
+  end
+
+  private
+  # Does the controller implement this action?
+  def self.control_implements?
+    return @@control.respond_to?(@@control.params[:action])
+  end
+
+  # Does the view implement this action?
+  def self.view_implements?
+    return !@@view.nil? && @@view.respond_to?(@@control.params[:action])
+  end
+
+end

data/lib/controller.rb

@@ -0,0 +1,222 @@
+require File.dirname(__FILE__) + "/filter.rb"
+
+# The Controller defines _actions_ for the application.  Each _action_ can be 
+# implemented as an instance method.
+#
+# == Sample Usage
+#   # .. inside controller.rb
+#   class MyController < SimpleConsole::Controller
+#     def say_hello
+#       puts "hello!"
+#     end
+#   end
+#
+#   # .. inside myapp
+#   # ..
+#   Application.run(ARGV, MyController)
+#
+# == What it did
+# The above example defines the action "say_hello".  So in the console:
+#
+#   % myapp say_hello
+#   hello!
+#
+# == Related Methods
+# Check out the "before_filter" and "after_filter" methods, similar to the
+# methods implemented in Rails.
+class SimpleConsole::Controller
+  attr_accessor :params
+
+  # Filter for methods to call previous to an action
+  @@before_chain = SimpleConsole::Filter.new
+
+  # Filter for methods to call after an action occurs
+  @@after_chain = SimpleConsole::Filter.new
+
+  # Keeps track of param types
+  @@params_parser = SimpleConsole::ParamsParser.new
+
+  # Initializes the "params" hash and creates a new Controller.  Not needed when
+  # developing an application with SimpleConsole.
+  def initialize()
+    @params = Hash.new
+  end
+
+  # Returns true if the controller defines the action given, otherwise returns
+  # false (returns false on private methods, also).
+  def respond_to?(action)
+    if @@block_action.include?(action.to_s)
+      return false
+    elsif private_methods.include?(action.to_s)
+      return false
+    else
+      super
+    end
+  end
+
+  # Sets the controller's params hash when given ARGV.
+  def set_params(argv)
+    # Set params[:id]
+    id = argv[1] if argv[1] && argv[1] !~ /^-/
+    if id.to_i == 0 && id != "0"
+      params[:id] = id
+    else
+      params[:id] = id.to_i 
+    end
+    params.update(@@params_parser.argv_to_params(argv))
+  end
+
+  # Sets the current action to the new action parameter. 
+  def set_action(action)
+    params[:action] = action
+  end
+
+  # Executes in order:
+  #   before_filter_for action
+  #   actual action
+  #   after_filter_for action
+  def execute_action
+    begin
+      params[:action] ||= :default
+      call_before_filter_for(params[:action])
+      send(params[:action]) if respond_to?(params[:action])
+      call_after_filter_for(params[:action])
+    rescue RuntimeError => error
+      raise error unless error.message == "Simple::Console Redirection"
+    end
+  end
+
+  protected
+  # When the view is rendered, this action is used instead
+  # == Example Usage
+  #   render(:action => :new_view)
+  def render(parameters)
+    params.update(parameters)
+  end
+
+  # A redirect will discontinue the current action and redirect to the new one
+  # with the updated params.
+  # == Example Usage
+  #   redirect_to(:action => :new_action)
+  def redirect_to(parameters)
+    params.update(parameters)
+    execute_action
+    raise RuntimeError, "Simple::Console Redirection"
+  end
+
+  # Returns an array of options that weren't specified by the params call.
+  # == Example Usage
+  #   params :string => {:f => :first, :s => :second},
+  #          :int => {:t => :third}
+  #   before_filter :check_params
+  #   # ...
+  #   def check_params
+  #     puts "Invalid option(s): " + invalid_params.join(", ")
+  #   end
+  # == On the command line
+  #   myapp --first one -t 3 --fourth oops --fifth huh?
+  #   Invalid option(s): --fourth, --fifth
+  def invalid_params
+    return @@params_parser.invalid_params
+  end
+
+  # Returns true if the user gave any invalid options.  To retrieve the list of
+  # invalid options use the method invalid_params.
+  def invalid_params?
+    return true if @@params_parser.invalid_params.size > 0
+    return false
+  end
+
+  private
+  # Calls all methods from "before_filter" for the given method.
+  #   controller.call_before_filter_for(:method)
+  # This will look for all "before_filter" :actions that are hooked onto
+  # :method and execute them right before :method is called.
+  def call_before_filter_for(method_name)
+    @@before_chain.filter_for(method_name).each do |method|
+      self.send(method)  
+    end
+  end
+
+  # Similar to "call_before_filter_for" except for the "after_filter".
+  def call_after_filter_for(method_name)
+    @@after_chain.filter_for(method_name).each do |method|
+      self.send(method)  
+    end
+  end
+
+  protected
+  # Executes a method before certain actions. 
+  #   before_filter :method  
+  #   before_filter :method, :only => [:only_before_this_method] 
+  #   before_filter :method, :except => [:not_for_this_method!]
+  #
+  # == Sample Usage
+  #   class MyController < SimpleConsole::Controller
+  #     before_filter :say_hello, :only => [:say_bye]
+  #
+  #     def say_bye
+  #       puts "bye!"
+  #     end
+  #
+  #     private
+  #     def say_hello
+  #       puts "hello!"
+  #     end
+  #   end
+  #
+  # Now whenever the action "say_bye" is executed, "say_hello" is executed right
+  # before it:
+  #
+  #   % myapp say_bye
+  #   hello!
+  #   bye!
+  def self.before_filter(method_to_call, options = nil)
+    @@before_chain.add_filter(method_to_call, options)
+  end
+
+  # Similar to "before_filter", except these methods are executed _AFTER_ 
+  # certain actions.
+  def self.after_filter(method_to_call, options = nil)
+    @@after_chain.add_filter(method_to_call, options)
+  end
+
+  # Sets the params that are accepted in a controller.
+  #   params :string => { :l => :long_name }
+  #
+  # Now, for your application:
+  #   % myapp action -l this_is_a_parameter
+  #
+  # This will result in 'params[:long_name] = "this_is_a_parameter"'
+  # Types include :string, :int, :text, and :bool.
+  #
+  # == Sample Usage
+  #   class MyController < SimpleConsole::Controller
+  #     params :int => { :i => :integer },
+  #            :string => { :n => :name, :t => :title },
+  #            :text => { :d => :description },
+  #            :bool => { :o => :open, :c => :closed}
+  #     
+  #     # ...
+  #   end
+  #
+  # On the command line:
+  #   % myapp action -i 1 --name Hugh -t Mr --description programmer --open
+  #
+  # In the controller, the params hash is set for each key using the long name:
+  #   params[:integer] = 1
+  #   params[:name] = "Hugh"
+  #   params[:title] = "Mr"
+  #   params[:description] = "programmer"
+  #   params[:open] = true
+  #   params[:closed] = nil  # because the -c or --closed switch wasn't set
+  def self.params(list)
+    @@params_parser.int_params(list[:int]) 
+    @@params_parser.string_params(list[:string])
+    @@params_parser.bool_params(list[:bool])
+    @@params_parser.text_params(list[:text])
+  end
+
+  # block all of these methods from being controller actions
+  @@block_action = self.new.methods
+end

data/lib/filter.rb

@@ -0,0 +1,69 @@
+# This class keeps track of filters - much like Rails filters for
+# ActionController.
+#
+# == Sample Usage
+#
+#   before_filter = Filter.new
+#   before_filter.add_filter :first
+#   before_filter.add_filter :second, :only => [:use_me]
+#   before_filter.add_filter :third, :except => [:use_me]
+#
+#   before_filter.filter_for(:use_me)
+#   # => Returns [:first, :second]
+class SimpleConsole::Filter
+
+  # Initializes the filter
+  def initialize
+    @filter_chain = Hash.new
+  end
+
+  # Adds a method call to the current filter.  Options include:
+  # * :except => Array
+  # * :only => Array
+  #
+  # == Sample Usage
+  #
+  #   chain = Filter.new
+  #   chain.add_filter(:first)                       
+  #   chain.add_filter(:second, :only => [:use_me]) 
+  #   chain.add_filter(:third, :except => [:dont_use_me])
+  #   # => Adds :first to all, :second only to :use_me, and :third to all except :dont_use_me
+  def add_filter(method_to_call, options = nil)
+    if options == nil
+      @filter_chain[method_to_call.to_sym] = true
+    elsif options.has_key?(:only)
+      @filter_chain[method_to_call.to_sym] = Hash.new
+      @filter_chain[method_to_call.to_sym][:only] = options[:only]
+    elsif options.has_key?(:except)
+      @filter_chain[method_to_call.to_sym] = Hash.new
+      @filter_chain[method_to_call.to_sym][:except] = options[:except]
+    end
+  end
+
+  # Returns a list of the methods in the filter for method_name.
+  #
+  # == Example Usage
+  #
+  #   chain = Filter.new
+  #   chain.add_filter(:first, :second)
+  #   chain.add_filter(:third, :fourth, :only => [:call_me])
+  #   chain.add_filter(:fifth, :sixth, :except => [:call_me])
+  #
+  #   filter_for(:call_me)
+  #   # => [:first, :second, :third, :fourth, :fifth]
+  def filter_for(method_name)
+    methods = Array.new
+    
+    @filter_chain.each do |method_to_call, option|
+      if option == true
+        methods << method_to_call
+      elsif option.has_key?(:only) && option[:only].include?(method_name.to_sym)
+        methods << method_to_call 
+      elsif option.has_key?(:except) && !option[:except].include?(method_name.to_sym)
+        methods << method_to_call 
+      end
+    end
+
+    return methods.uniq
+  end
+end

data/lib/init.rb

@@ -0,0 +1,22 @@
+# Handles the initialization of SimpleConsole by requiring all files and putting
+# the classes under the SimpleConsole module.
+
+# SimpleConsole is a module used for building command-line applications.
+# The three most important methods are SimpleConsole::Controller,
+# SimpleConsole::View, and SimpleConsole::Application.
+module SimpleConsole 
+  class Filter
+  end
+  class ParamsParser
+  end
+  class Controller
+  end
+  class View
+  end
+  class Application
+  end
+end
+
+Dir.glob(File.dirname(__FILE__) + "/*.rb").uniq.each do |file|
+  require file
+end

data/lib/params_parser.rb

@@ -0,0 +1,89 @@
+class SimpleConsole::ParamsParser
+  def initialize
+    @letter_to_key ||= Hash.new
+    @key_types ||= Hash.new
+    @letter_types ||= Hash.new
+    @error_list ||= Array.new
+  end
+
+  def int_params(list) 
+    set_key(list, :int) 
+  end
+
+  def text_params(list)
+    set_key(list, :text)
+  end
+
+  def string_params(list)
+    set_key(list, :string)
+  end
+
+  def bool_params(list)
+    set_key(list, :bool)
+  end
+
+  def argv_to_params(argv)
+    params = Hash.new
+    @letter_to_key ||= Hash.new
+    argv.each do |arg|
+      if arg =~ /^--(.*)$/
+        argument = $1
+        value = argv[argv.index(arg) + 1]
+        if @letter_to_key.has_value?(argument.to_sym)
+          params[argument.to_sym] = get_value_of(value, argument.to_sym)
+        else
+          add_error(arg)
+        end
+      elsif arg =~ /^-(.)/
+        argument = $1
+        value = argv[argv.index(arg) + 1]
+        if @letter_to_key.has_key?(argument.to_sym)
+          argument = @letter_to_key[argument.to_sym]
+          params[argument.to_sym] = get_value_of(value, argument.to_sym)
+        else
+          add_error(arg)
+        end
+      end
+    end
+
+    return params
+  end
+
+  def invalid_params
+    @error_list ||= Array.new
+    return @error_list
+  end
+  
+  private
+  def set_key(list, type)
+    return if !list
+    @letter_to_key ||= Hash.new
+    @key_types ||= Hash.new
+    @letter_types ||= Hash.new
+    @letter_to_key.update(list)
+    list.each do |letter, key| 
+      @key_types[key] = type 
+      @letter_types[letter] = type 
+    end
+  end
+
+  def add_error(error)
+    @error_list ||= Array.new
+    @error_list << error
+  end
+
+  def get_value_of(value, key)
+    type = @key_types[key] if @key_types.has_key?(key)
+    type = @letter_types[key] if @letter_types.has_key?(key)
+
+    if type == :int
+      return value.to_i
+    elsif type == :text
+      return value.to_s
+    elsif type == :string
+      return value.to_s
+    elsif type == :bool
+      return true
+    end
+  end
+end

data/lib/simpleconsole.rb

@@ -0,0 +1,22 @@
+# Handles the initialization of SimpleConsole by requiring all files and putting
+# the classes under the SimpleConsole module.
+
+# SimpleConsole is a module used for building command-line applications.
+# The three most important methods are SimpleConsole::Controller,
+# SimpleConsole::View, and SimpleConsole::Application.
+module SimpleConsole 
+  class Filter
+  end
+  class ParamsParser
+  end
+  class Controller
+  end
+  class View
+  end
+  class Application
+  end
+end
+
+Dir.glob(File.dirname(__FILE__) + "/*.rb").uniq.each do |file|
+  require file
+end

data/lib/view.rb

@@ -0,0 +1,56 @@
+# The View is meant to render the output for each action in the Controller.
+# Each 'view template' is just another method definition, usually with a lot of
+# 'puts' method calls.  The instance variables of the Controller is injected
+# into the View, so if @var is set in the controller, you can access it in the
+# view.
+#
+# == Sample Usage
+#   class MyController < SimpleConsole::Controller
+#     def say_hello
+#       @word = "Hello!"
+#     end
+#   end
+#
+#   class MyView < SimpleConsole::View
+#     def say_hello
+#       puts @word
+#     end
+#   end
+#
+#   SimpleConsole::Application.run(ARGV, MyController, MyView)
+#
+# == What it did
+# The above example defines the action "say_hello".  So in the console:
+#
+#   % myapp say_hello
+#   Hello!
+#
+# == Related Methods
+# Check out SimpleConsole::Controller's render method, which can change which
+# view template is rendered.
+class SimpleConsole::View
+  attr_accessor :params
+  
+  # Llinks the view to the controller
+  def initialize(controller) #:nodoc
+    @control = controller
+  end
+
+  # Renders the current action, the default being @control's params[:action]
+  def render_action(action = @control.params[:action]) #:nodoc
+    set_variables
+    begin
+      send(action) if respond_to?(action)
+    rescue TypeError => error
+      raise TypeError, "params[:action] should be set to :default if no action is given"
+    end
+  end
+
+  private
+  # Sets the instance variables of this view to be the same as it's @control.
+  def set_variables #:nodoc
+    @control.instance_variables.each do |var|
+      instance_variable_set(var, @control.instance_variable_get(var))
+    end
+  end
+end

data/test/test_application.rb

@@ -0,0 +1,61 @@
+require "test/unit"
+require "rubygems"
+require "mocha"
+require "stubba"
+require File.dirname(__FILE__) + "/../lib/init.rb"
+
+class AppControl < SimpleConsole::Controller
+  def method_missing(method_name)
+  end
+end
+
+class TwoAppControl < SimpleConsole::Controller
+end
+
+class TestApplication < Test::Unit::TestCase
+  include SimpleConsole
+
+  def setup
+    @call_chain = [:call_before_filter_for, :call_after_filter_for]
+  end
+
+  def teardown
+  end
+
+  # Sets a controller object to pass into Application.run
+  def set_control(method_call = nil)
+    control = mock
+    control.expects(:new).at_least_once.returns(control)
+    control.expects(:execute_action).at_least_once
+    control.expects(:params).at_least_once.returns({:action => method_call})
+    control.expects(:set_action).at_least_once
+    control.expects(:set_params).at_least_once
+    
+    control.expects(method_call).at_least_once if method_call
+
+    return control
+  end
+
+  # Sets a view object to pass into Application.run
+  def set_view
+    view = mock
+    view.expects(:new).at_least_once.returns(view)
+    view.expects(:render_action).at_least_once
+
+    return view
+  end
+
+  def test_basic_control_run
+    Application.stubs(:control_implements?).returns(false)
+
+    # Run with default action, only controller no view
+    Application.run(Array.new, set_control(:default))
+  end
+
+  # Run tests where the controller and view don't implement action
+  def test_control_view_no_action_run
+    # Run with method_missing because neither controller or view has action
+    Application.run([:action], AppControl, set_view)
+  end
+end
+

data/test/test_controller.rb

@@ -0,0 +1,56 @@
+require "test/unit"
+require "rubygems"
+require "stubba"
+require File.dirname(__FILE__) + "/../lib/init.rb"
+
+# SampleController for tests usage.
+# :say_hi should be followed by a :say_bye
+# :bye should be prepended with a :hello
+class SampleController < SimpleConsole::Controller
+  before_filter :say_hi, :only => [:say_bye]
+  after_filter :bye, :except => [:say_bye]
+
+  def say_bye; "bye"; end
+
+  def hello; "hello"; end
+
+  def default; redirect_to :action => :say_bye; raise "I shouldn't raise"; end
+
+  def say_hi; "hi"; end
+  
+  def bye; "goodbye"; end
+end
+
+class TestController < Test::Unit::TestCase
+  def setup
+    @control = SampleController.new
+  end
+
+  def teardown
+  end
+
+  def test_filters_for_execute_action
+    @control.expects(:say_hi).at_least_once
+    @control.expects(:say_bye).at_least_once
+    @control.set_action(:say_bye)
+    @control.execute_action
+
+    @control.expects(:hello).times(1)
+    @control.expects(:bye).times(1)
+    @control.set_action(:hello)
+    @control.execute_action
+  end
+
+  def test_no_filters
+    control = SimpleConsole::Controller.new
+
+    assert_raise(NoMethodError) { control.execute_action } 
+  end
+
+  def test_execute_action_with_redirect
+    control = SampleController.new    
+    control.expects(:say_bye).at_least_once
+    assert_nothing_raised(RuntimeError) { control.execute_action }
+  end
+
+end

data/test/test_filter.rb

@@ -0,0 +1,77 @@
+require "test/unit"
+require File.dirname(__FILE__) + "/../lib/init.rb"
+
+class TestFilter < Test::Unit::TestCase
+  def setup
+    @filter = SimpleConsole::Filter.new
+  end
+
+  def teardown
+  end
+
+  def filter_chain
+    return @filter.instance_variable_get(:@filter_chain)
+  end
+
+  def assert_similar_arrays(expected, actual)
+    expected.each do |item|
+      assert(actual.include?(item))
+    end
+
+    actual.each do |item|
+      assert(expected.include?(item))
+    end
+  end
+
+  def test_add_filter_without_arguments
+    assert_raise(ArgumentError) { @filter.add_filter }
+  end
+
+  def test_filter_all
+    filters = Array.new
+    methods = [:one, :two, :three, :four, :five]
+
+    methods.each do |method|
+      filters << method
+      @filter.add_filter method
+
+      assert_similar_arrays(filters, @filter.filter_for(:random))
+    end
+  end
+
+  def test_filter_only
+    filters = Hash.new
+    filters[:one] = [:method_one, :method1, :one_method]
+    filters[:two] = [:method_two, :method2, :two_method]
+    filters[:three] = [:method_three, :method3, :three_method]
+    filters[:all] = filters[:one] + filters[:two] + filters[:three]
+
+    filters.each do |filter, methods|
+      methods.each { |method| @filter.add_filter method, :only => [filter, :all] } unless filter == :all
+    end
+
+    filters.each do |filter, methods|
+      assert_similar_arrays(methods, @filter.filter_for(filter))
+    end
+  end
+
+  def test_filter_except
+    filters = Hash.new
+
+    ones = [:method_one, :method1, :one_method]
+    twos = [:method_two, :method2, :two_method]
+    threes = [:method_three, :method3, :three_method]
+
+    filters[:one] = twos + threes
+    filters[:two] = ones + threes
+    filters[:three] = ones + twos
+
+    ones.each { |m| @filter.add_filter m, :except => [:one] }
+    twos.each { |m| @filter.add_filter m, :except => [:two] }
+    threes.each { |m| @filter.add_filter m, :except => [:three] }
+
+    filters.each do |filter, methods|
+      assert_similar_arrays(methods, @filter.filter_for(filter))
+    end
+  end
+end

data/test/test_params_parser.rb

@@ -0,0 +1,51 @@
+require "test/unit"
+require File.dirname(__FILE__) + "/../lib/init.rb"
+
+class TestParamsParser < Test::Unit::TestCase
+  def setup
+    @parser = SimpleConsole::ParamsParser.new
+  end
+
+  def teardown
+  end
+
+  def assert_same_hash(expected, result)
+    expected.each do |key, value|
+      assert(result.has_key?(key) && result.has_value?(value))
+      assert_equal(value, result[key])
+    end
+
+    result.each do |key, value|
+      assert(expected.has_key?(key) && expected.has_value?(value))
+      assert_equal(value, expected[key])
+    end
+  end
+
+  def test_int
+    @parser.int_params(:i => :id, :f => :float)
+    argv = ["-i", "1", "--float", "2"]
+
+    assert_same_hash({:id => 1, :float => 2}, @parser.argv_to_params(argv))
+  end
+
+  def test_bool
+    @parser.bool_params(:o => :open, :c => :close)
+    argv = ["-o", "doesn't matter", "--close", "--open"]
+
+    assert_same_hash({:open => true, :close => true}, @parser.argv_to_params(argv))
+  end
+
+  def test_text
+    @parser.text_params(:d => :description, :t => :text)
+    argv = ["-d", "a description", "--text", "the text"]
+    
+    assert_same_hash({:description => "a description", :text => "the text"}, @parser.argv_to_params(argv))
+  end
+
+  def test_string
+    @parser.string_params(:s => :string, :t => :title)
+    argv = ["-s", "a string", "--title", "the title"]
+
+    assert_same_hash({:string => "a string", :title => "the title"}, @parser.argv_to_params(argv))
+  end
+end

data/test/test_view.rb

@@ -0,0 +1,32 @@
+require "test/unit"
+require "rubygems"
+require "mocha"
+require File.dirname(__FILE__) + "/../lib/init.rb"
+
+class TestView < Test::Unit::TestCase
+  include SimpleConsole
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_render_action
+    controller = Controller.new
+    controller.set_action(:default)
+
+    view = View.new(controller)
+    view.render_action
+
+    assert_equal(controller.params[:action], view.params[:action])
+  end
+
+  def test_render_non_existant_action
+    controller = Controller.new
+    view = nil
+
+    assert_nothing_raised { view = View.new(controller) }
+    assert_raise (TypeError) { view.render_action }
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: simpleconsole
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2006-09-18 00:00:00 -07:00
+summary: Microframework for developing console apps quickly.
+require_paths: 
+- lib
+email: bienhd@gmail.com
+homepage: http://simpleconsole.rubyforge.org
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: simcon
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Hugh Bien
+files: 
+- bin/execute
+- bin/files
+- bin/simcon
+- bin/files/application.rb
+- bin/files/controller.rb
+- bin/files/Rakefile
+- bin/files/single.rb
+- bin/files/view.rb
+- test/test_application.rb
+- test/test_controller.rb
+- test/test_filter.rb
+- test/test_init.rb
+- test/test_params_parser.rb
+- test/test_view.rb
+- lib/application.rb
+- lib/controller.rb
+- lib/filter.rb
+- lib/init.rb
+- lib/params_parser.rb
+- lib/simpleconsole.rb
+- lib/view.rb
+- README
+- MIT-LICENSE
+test_files: 
+- test/test_application.rb
+- test/test_controller.rb
+- test/test_filter.rb
+- test/test_init.rb
+- test/test_params_parser.rb
+- test/test_view.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+- MIT-LICENSE
+executables: 
+- simcon
+extensions: []
+
+requirements: []
+
+dependencies: []
+