rubikon 0.1.0

data/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2009, Sebastian Staudt
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+* Neither the name of the author nor the names of its contributors
+  may be used to endorse or promote products derived from this software
+  without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,129 @@
+Rubikon
+=======
+
+Rubikon is a simple to use, yet powerful Ruby framework for building
+console-based applications.
+
+### Installation
+
+You can install Rubikon using RubyGem. This is the easiest way of installing
+and recommended for most users.
+
+    $ gem install rubikon
+
+If you want to use the development code you should clone the Git repository:
+
+    $ git clone git://github.com/koraktor/rubikon.git
+    $ cd rubikon
+    $ rake install
+
+## Usage
+
+Creating a Rubikon application is as simple as creating a Ruby class:
+
+    require 'rubygems'
+    require 'rubikon'
+
+    class MyApplication < Rubikon::Application
+    end
+
+If you save this code in a file called `myapp.rb` you can run it using
+`ruby myapp.rb`. Or you could even add a *shebang* (`#!/usr/bin/env ruby`) to
+the top of the file and make it executable. You would then be able to run it
+even more easy by typing `./myapp.rb`.
+
+Now go on and define what your application should do when the user runs it.
+This is done using `default`:
+
+    class MyApplication < Rubikon::Application
+
+      default do
+        puts 'Hello World!'
+      end
+
+    end
+
+If you run this application it will just print `Hello World!`.
+
+You can also add command-line options to your appication using `action`:
+
+    class MyApplication < Rubikon::Application
+
+      action 'hello' do
+        puts 'Hello World!'
+      end
+
+    end
+
+This way your application would do nothing when called without options, but it
+would print `Hello World!` when called using `ruby myapp.rb --hello`.
+Please note that Rubikon will add dashes to options by default. If you don't
+like this behaviour and want options like RubyGem's `install` or `update` just
+use the following inside your application class:
+
+    set :dashed_options, false
+
+Please see the `samples` directory for more in detail sample applications.
+
+
+**Warning**:
+
+Rubikon is still in an early development stage. If you want to use it be aware
+that you will probably run into problems and or restrictions. See the
+Contribute section if you want to help making Rubikon better.
+
+## Features
+
+* A simple to use DSL
+* Automatic checks for option arguments
+* User defined type safety of option arguments
+* Built-in methods to capture user input and display throbbers
+
+## Future plans
+
+* Automatic generation of help screens
+* Improved error handling
+* Built-in support for configuration files
+* Built-in support for colored output and progress bars
+
+## Requirements
+
+* Linux, MacOS X or Windows
+* Ruby 1.8.6 or newer
+
+## Contribute
+
+There are several ways of contributing to Rubikon's development:
+
+* Build apps using it and spread the word.<br />
+* Report problems and request features using the [issue tracker][2].
+* Write patches yourself to fix bugs and implement new functionality.
+* Create a Rubikon fork on [GitHub][1] and start hacking.
+
+## About the name
+
+Rubikon is the German name of the river Rubicone in Italy. It had a historical
+relevance in ancient Rome when Julius Caesar crossed that river with his army
+and thereby declared war to the Roman senate. The phrase "to cross the Rubicon"
+originates from this event.
+
+You may also see Rubikon as a morphed composition of *"Ruby"* and *"console"*.
+
+## License
+
+This code is free software; you can redistribute it and/or modify it under the
+terms of the new BSD License. A copy of this license can be found in the LICENSE
+file.
+
+## Credits
+
+* Sebastian Staudt -- koraktor(at)gmail.com
+
+## See Also
+
+* [API documentation](http://www.rdoc.info/projects/koraktor/rubikon)
+* [GitHub project page][1]
+* [GitHub issue tracker][2]
+
+ [1]: http://github.com/koraktor/rubikon
+ [2]: http://github.com/koraktor/rubikon/issues

data/Rakefile

@@ -0,0 +1,55 @@
+# This code is free software; you can redistribute it and/or modify it under the
+# terms of the new BSD License.
+#
+# Copyright (c) 2009, Sebastian Staudt
+
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+src_files = Dir.glob(File.join('lib', '**', '*.rb'))
+test_files = Dir.glob(File.join('test', '**', '*.rb'))
+
+task :default => :test
+
+# Test task
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.test_files = test_files
+  t.verbose = true
+end
+
+begin
+  require 'jeweler'
+  # Gem specification
+  Jeweler::Tasks.new do |gem|
+    gem.authors = ['Sebastian Staudt']
+    gem.email = 'koraktor@gmail.com'
+    gem.description = 'A simple to use, yet powerful Ruby framework for building console-based applications.'
+    gem.date = Time.now
+    gem.homepage = 'http://koraktor.github.com/rubikon'
+    gem.name = gem.rubyforge_project = 'rubikon'
+    gem.summary = 'Rubikon - A Ruby console app framework'
+
+    gem.files = %w(README.md Rakefile LICENSE VERSION.yml) + src_files + test_files
+    gem.rdoc_options = ['--all', '--inline-source', '--line-numbers', '--charset=utf-8', '--webcvs=http://github.com/koraktor/rubikon/blob/master/%s']
+  end
+rescue LoadError
+  puts "You need Jeweler to build the gem. Install it using `gem install jeweler`."
+end
+
+# Create a rake task +:rdoc+ to build the documentation
+desc 'Building docs'
+Rake::RDocTask.new do |rdoc|
+  rdoc.title = 'Rubikon - API documentation'
+  rdoc.rdoc_files.include ['lib/**/*.rb', 'LICENSE', 'README.md']
+  rdoc.main = 'README.md'
+  rdoc.rdoc_dir = 'doc'
+  rdoc.options = ['--all', '--inline-source', '--line-numbers', '--charset=utf-8', '--webcvs=http://github.com/koraktor/rubikon/blob/master/%s']
+end
+
+# Task for cleaning documentation and package directories
+desc 'Clean documentation and package directories'
+task :clean do
+  FileUtils.rm_rf 'doc'
+  FileUtils.rm_rf 'pkg'
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+---
+:major: 0
+:minor: 1
+:patch: 0

data/lib/rubikon/action.rb

@@ -0,0 +1,71 @@
+# This code is free software; you can redistribute it and/or modify it under the
+# terms of the new BSD License.
+#
+# Copyright (c) 2009, Sebastian Staudt
+
+module Rubikon
+
+  # Instances of the Action class are used to define the real code that should
+  # be executed when running the application.
+  class Action
+
+    @@action_count = 0
+
+    attr_reader :block, :description, :name, :param_type
+
+    # Create a new Action using the given name, options and code block.
+    #
+    # +name+::    The name of this Action, used in Application options
+    # +options+:: A Hash of options that define more details about the Action
+    # +block+::   The code block which should be executed by this Action
+    #
+    # Options:
+    # +description+:: A description of the action. This isn't used at the
+    #                 moment.
+    # +param_type+::  A single Class or a Array of classes that represent the
+    #                 type(s) of argument(s) this action expects
+    def initialize(name, options = {}, &block)
+      raise BlockMissingError unless block_given?
+
+      @name = name
+
+      @description = options[:description] || ''
+      @param_type = options[:param_type] || Object
+
+      @block = block
+    end
+
+    # Run this action's code block
+    #
+    # +args+:: The argument which should be relayed to the block of this Action
+    def run(*args)
+      if (@block.arity >= 0 and args.size < @block.arity) or (@block.arity < 0 and args.size < -@block.arity - 1)
+        raise MissingArgumentError
+      end
+      raise Rubikon::ArgumentTypeError unless check_argument_types(args)
+      @block[*args]
+    end
+
+    private
+
+    # Checks the types of the given arguments using the Class or Array of
+    # classes given in the +:param_type+ option of this action.
+    #
+    # +args+:: The arguments which should be checked
+    def check_argument_types(args)
+      if @param_type.is_a? Array
+        args.each_index do |i|
+          return false unless args[i].is_a? @param_type[i]
+        end
+      else
+        args.each do |arg|
+          return false unless arg.is_a? @param_type
+        end
+      end
+
+      true
+    end
+
+  end
+
+end

data/lib/rubikon/application.rb

@@ -0,0 +1,331 @@
+# This code is free software; you can redistribute it and/or modify it under the
+# terms of the new BSD License.
+#
+# Copyright (c) 2009, Sebastian Staudt
+
+require 'singleton'
+require 'yaml'
+
+require 'rubikon/action'
+require 'rubikon/exceptions'
+
+module Rubikon
+
+  version = YAML.load_file(File.join(File.dirname(__FILE__), '..', '..', 'VERSION.yml'))
+  VERSION = "#{version[:major]}.#{version[:minor]}.#{version[:patch]}"
+
+  # The main class of Rubikon. Let your own application class inherit from this
+  # one.
+  class Application
+
+    include Singleton
+
+    attr_reader :settings
+
+    # Initialize with default settings (see set for more detail)
+    #
+    # If you really need to override this in your application class, be sure to
+    # call +super+
+    def initialize
+      @actions  = {}
+      @aliases  = {}
+      @default  = nil
+      @settings = {
+        :autorun        => true,
+        :dashed_options => true,
+        :help_banner    => "Usage: #{$0}",
+        :istream        => $stdin,
+        :name           => self.class.to_s,
+        :ostream        => $stdout,
+        :raise_errors   => false
+      }
+    end
+
+    # Define an Application Action
+    #
+    # +name+::    The name of the action. Used as an option parameter.
+    # +options+:: A Hash of options to be used on the created Action
+    #             (default: <tt>{}</tt>)
+    # +block+::   A block containing the code that should be executed when this
+    #             Action is called, i.e. when the Application is called with
+    #             the associated option parameter
+    def action(name, options = {}, &block)
+      raise "No block given" unless block_given?
+
+      key = name
+      key = "--#{key}" if @settings[:dashed_options]
+
+      @actions[key.to_sym] = Action.new(name, options, &block)
+    end
+
+    # Define an alias to an Action
+    #
+    # +name+::   The name of the alias
+    # +action+:: The name of the Action that should be aliased
+    #
+    # Example:
+    #
+    #  action_alias :doit, :dosomething
+    def action_alias(name, action)
+      @aliases[name.to_sym] = action.to_sym
+    end
+
+    # Define the default Action of the Application
+    #
+    # +options+:: A Hash of options to be used on the created Action
+    #             (default: <tt>{}</tt>)
+    # +block+::   A block containing the code that should be executed when this
+    #             Action is called, i.e. when no option is given to the
+    #             Application
+    def default(options = {}, &block)
+      @default = Action.new(:default, options, &block)
+    end
+
+    # Prompts the user for input
+    #
+    # If +prompt+ is not empty this will display a prompt using
+    # <tt>prompt.to_s</tt>.
+    #
+    # +prompt+:: A String or other Object responding to +to_s+ used for
+    #            displaying a prompt to the user (default: <tt>''</tt>)
+    #
+    # Example:
+    #
+    #  action 'interactive' do
+    #    # Display a prompt "Please type something: "
+    #    user_provided_value = input 'Please type something'
+    #
+    #    # Do something with the data
+    #    ...
+    #  end
+    def input(prompt = '')
+      unless prompt.to_s.empty?
+        ostream << "#{prompt}: "
+      end
+      @settings[:istream].gets[0..-2]
+    end
+
+    # Convenience method for accessing the user-defined output stream
+    #
+    # Use this if you want to work directly with the output stream
+    #
+    # Example:
+    #
+    #  ostream.flush
+    def ostream
+      @settings[:ostream]
+    end
+
+    # Output text using +IO#<<+ of the output stream
+    #
+    # +text+:: The text to write into the output stream
+    def put(text)
+      ostream << text
+      ostream.flush
+    end
+
+    # Output a character using +IO#putc+ of the output stream
+    #
+    # +char+:: The character to write into the output stream
+    def putc(char)
+      ostream.putc char
+    end
+
+    # Output a line of text using +IO#puts+ of the output stream
+    #
+    # +text+:: The text to write into the output stream
+    def puts(text)
+      ostream.puts text
+    end
+
+    # Run this application
+    #
+    # +args+:: The command line arguments that should be given to the
+    #          application as options
+    #
+    # Calling this method explicitly is not required when you want to create a
+    # simple application (having one main class inheriting from
+    # Rubikon::Application). But it's useful for testing or if you want to have
+    # some sort of sub-applications.
+    def run(args = ARGV)
+      begin
+        assign_aliases unless @aliases.empty?
+        action_results = []
+
+        if !@default.nil? and args.empty?
+          action_results << @default.run
+        else
+          parse_options(args).each do |action, args|
+            action_results << @actions[action].run(*args)
+          end
+        end
+      rescue
+        if @settings[:raise_errors]
+          raise $!
+        else
+          puts "Error:\n    #{$!.message}"
+          puts "    #{$!.backtrace.join("\n    ")}" if $DEBUG
+          exit 1
+        end
+      end
+
+      action_results
+    end
+
+    # Sets an application setting
+    #
+    # +setting+:: The name of the setting to change, will be symbolized first.
+    # +value+::   The value the setting should be changed to
+    #
+    # Available settings
+    # +autorun+::        If true, let the application run as soon as its class
+    #                    is defined
+    # +dashed_options+:: If true, each option is prepended with a double-dash
+    #                    (<tt>-</tt><tt>-</tt>)
+    # +help_banner+::    Defines a banner for the help message (<em>unused</em>)
+    # +istream+::        Defines an input stream to use
+    # +name+::           Defines the name of the application
+    # +ostream+::        Defines an output stream to use
+    # +raise_errors+::   If true, raise errors, otherwise fail gracefully
+    #
+    # Example:
+    #
+    #  set :name, 'My App'
+    #  set :autorun, false
+    def set(setting, value)
+      @settings[setting.to_sym] = value
+    end
+
+    # Displays a throbber while the given block is executed
+    #
+    # Example:
+    #
+    #  action 'slow' do
+    #    throbber do
+    #      # Add some long running code here
+    #      ...
+    #    end
+    #  end
+    def throbber(&block)
+      spinner = '-\|/'
+      current_ostream = ostream
+      @settings[:ostream] = StringIO.new
+
+      code_thread = Thread.new { block.call }
+
+      throbber_thread = Thread.new do
+        i = 0
+        current_ostream.putc 32
+        while code_thread.alive?
+          current_ostream.putc 8
+          current_ostream.putc spinner[i]
+          current_ostream.flush
+          i = (i + 1) % 4
+          sleep 0.25
+        end
+        current_ostream.putc 8
+      end
+
+      code_thread.join
+      throbber_thread.join
+
+      current_ostream << ostream.string
+      @settings[:ostream] = current_ostream
+    end
+
+    private
+
+    # Returns whether this application should be ran automatically
+    def self.autorun?
+      instance.settings[:autorun] || false
+    end
+
+    # Enables autorun functionality using <tt>Kernel#at_exit</tt>
+    #
+    # +subclass+:: The subclass inheriting from Application. This is the user's
+    #              application.
+    #
+    # <em>This is called automatically when subclassing Application.</em>
+    def self.inherited(subclass)
+      Singleton.__init__(subclass)
+      at_exit { subclass.run if subclass.autorun? }
+    end
+
+    # This is used for convinience. Method calls on the class itself are
+    # relayed to the singleton instance.
+    #
+    # +method_name+:: The name of the method being called
+    # +args+::        Any arguments that are given to the method
+    # +block+::       A block that may be given to the method
+    #
+    # <em>This is called automatically when calling methods on the class.</em>
+    def self.method_missing(method_name, *args, &block)
+      instance.send(method_name, *args, &block)
+    end
+
+    # Relay putc to the instance method
+    #
+    # This is used to hide <tt>Kernel#putc</tt> so that the Application's
+    # output IO object is used for printing text
+    #
+    # +text+:: The text to write into the output stream
+    def self.putc(text)
+      instance.putc text
+    end
+
+    # Relay puts to the instance method
+    #
+    # This is used to hide <tt>Kernel#puts</tt> so that the Application's
+    # output IO object is used for printing text
+    #
+    # +text+:: The text to write into the output stream
+    def self.puts(text)
+      instance.puts text
+    end
+
+    # Assigns aliases to the actions that have been defined using action_alias
+    #
+    # Clears the aliases Hash afterwards
+    def assign_aliases
+      @aliases.each do |key, action|
+        if @settings[:dashed_options]
+          action = "--#{action}".to_sym
+          key = "--#{key}".to_sym
+        end
+
+        unless @actions.key? key
+          @actions[key] = @actions[action]
+        else
+          warn "There's already an action called \"#{key}\"."
+        end
+      end
+
+      @aliases = {}
+    end
+
+    # Parses the options used when starting the application
+    #
+    # +options+:: An Array of Strings that should be used as application
+    #             options. Usually +ARGV+ is used for this.
+    def parse_options(options)
+      actions_to_call = {}
+      last_action     = nil
+
+      options.each do |option|
+        option_sym = option.to_sym
+        if @actions.keys.include? option_sym
+          actions_to_call[option_sym] = []
+          last_action = option_sym
+        elsif last_action.nil? || (option.is_a?(String) && @settings[:dashed_options] && option[0..1] == '--')
+          raise UnknownOptionError.new(option)
+        else
+          actions_to_call[last_action] << option
+        end
+      end
+
+      actions_to_call
+    end
+
+  end
+
+end

data/lib/rubikon/exceptions.rb

@@ -0,0 +1,28 @@
+# This code is free software; you can redistribute it and/or modify it under the
+# terms of the new BSD License.
+#
+# Copyright (c) 2009, Sebastian Staudt
+
+module Rubikon
+
+  class ArgumentTypeError < ArgumentError
+  end
+
+  class BlockMissingError < ArgumentError
+  end
+
+  class MissingArgumentError < ArgumentError
+  end
+
+  class MissingOptionError < ArgumentError
+  end
+
+  class UnknownOptionError < ArgumentError
+
+    def initialize(arg)
+      super "Unknown argument: #{arg}"
+    end
+
+  end
+
+end

data/lib/rubikon.rb

@@ -0,0 +1,9 @@
+# This code is free software; you can redistribute it and/or modify it under the
+# terms of the new BSD License.
+#
+# Copyright (c) 2009, Sebastian Staudt
+
+libdir = File.dirname(__FILE__)
+$:.unshift(libdir) unless $:.include?(libdir)
+
+require 'rubikon/application'

data/test/test.rb

@@ -0,0 +1,173 @@
+# This code is free software; you can redistribute it and/or modify it under the
+# terms of the new BSD License.
+#
+# Copyright (c) 2009, Sebastian Staudt
+
+require 'rubygems'
+require 'shoulda'
+
+begin require 'redgreen'; rescue LoadError; end
+
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+$: << File.dirname(__FILE__)
+require 'rubikon'
+require 'testapp'
+
+class RubikonTests < Test::Unit::TestCase
+
+  context 'A Rubikon application\'s class' do
+
+    setup do
+      @app = RubikonTestApp.instance
+    end
+
+    should 'run it\'s instance for called methods' do
+      assert_equal @app.run(%w{--object_id}), RubikonTestApp.run(%w{--object_id})
+    end
+  end
+
+  context 'A Rubikon application' do
+
+    setup do
+      @app = RubikonTestApp
+      @ostream = StringIO.new
+      @app.set :ostream, @ostream
+    end
+
+    should 'be a singleton' do
+      assert_raise NoMethodError do
+        RubikonTestApp.new
+      end
+    end
+
+    should 'exit gracefully' do
+      unknown = '--unknown'
+      @app.set :raise_errors, false
+      begin
+        @app.run([unknown])
+      rescue Exception => e
+      end
+      assert_instance_of SystemExit, e
+      assert_equal 1, e.status
+      @ostream.rewind
+      assert_equal "Error:\n", @ostream.gets
+      assert_equal "    Unknown argument: #{unknown}\n", @ostream.gets
+      @app.set :raise_errors, true
+    end
+
+    should 'run it\'s default action without options' do
+      result = @app.run
+      assert_equal 1, result.size
+      assert_equal 'default action', result.first
+    end
+
+    should 'run with a mandatory option' do
+      result = @app.run(%w{--required arg})
+      assert_equal 1, result.size
+      assert_equal 'required argument was arg', result.first
+    end
+
+    should 'not run without a mandatory argument' do
+      assert_raise Rubikon::MissingArgumentError do
+        @app.run(%w{--required})
+      end
+    end
+
+    should 'require an argument type if it has been defined' do
+      assert_raise Rubikon::ArgumentTypeError do
+        @app.run(['--output', 6])
+      end
+      assert_raise Rubikon::ArgumentTypeError do
+        @app.run(['--number_string', 6, 7])
+      end
+      assert_raise Rubikon::ArgumentTypeError do
+        @app.run(['--number_string', 'test' , 6])
+      end
+    end
+
+    should 'raise an exception when calling an action with the wrong number of
+            arguments' do
+      assert_raise Rubikon::MissingArgumentError do
+        @app.run(%w{--output})
+      end
+      assert_raise ArgumentError do
+        @app.run(%w{--output}, 'test', 3)
+      end
+    end
+
+    should 'raise an exception when using an unknown option' do
+      assert_raise Rubikon::UnknownOptionError do
+        @app.run(%w{--unknown})
+      end
+      assert_raise Rubikon::UnknownOptionError do
+        @app.run(%w{--noarg --unknown})
+      end
+      assert_raise Rubikon::UnknownOptionError do
+        @app.run(%w{--unknown --noarg})
+      end
+    end
+
+    should 'be able to handle user input' do
+      @istream = StringIO.new
+      @app.set :istream, @istream
+
+      input_string = 'test'
+      @istream.puts input_string
+      @istream.rewind
+      assert_equal [input_string], @app.run(%w{--input})
+      @ostream.rewind
+      assert_equal 'input: ', @ostream.gets
+    end
+
+    should 'write output to the user given output stream' do
+      input_string = 'test'
+      @app.run(['--output', input_string])
+      @ostream.rewind
+      assert_equal "#{input_string}\n", @ostream.gets
+      assert_equal "#{input_string}#{input_string[0].chr}", @ostream.gets
+    end
+
+    should 'provide a throbber' do
+      @app.run(%w{--throbber})
+      @ostream.rewind
+      assert_equal " \b-\b\\\b|\b/\b", @ostream.string
+      @app.run(%w{--throbber true})
+      @ostream.rewind
+      assert_equal " \b-\b\\\b|\b/\bdon't\nbreak\n", @ostream.string
+    end
+
+    should 'have working action aliases' do
+      assert_equal @app.run(%w{--alias_before}), @app.run(%w{--object_id})
+      assert_equal @app.run(%w{--alias_after}), @app.run(%w{--object_id})
+    end
+
+  end
+
+  context 'A Rubikon action' do
+
+    should 'throw an exception when no code block is given' do
+      assert_raise Rubikon::BlockMissingError do
+        Rubikon::Action.new 'name'
+      end
+      assert_raise Rubikon::BlockMissingError do
+        Rubikon::Action.new 'name', {}
+      end
+    end
+
+    should 'not raise an exception when created without options' do
+      action_name = 'someaction'
+      action_options = {
+        :description => 'this is an action',
+        :param_type  => String
+      }
+      assert_nothing_raised do
+        action = Rubikon::Action.new action_name, action_options do end
+        assert_equal action_name, action.name
+        assert_equal action_options[:description], action.description
+        assert_equal action_options[:param_type], action.param_type
+      end
+    end
+
+  end
+
+end

data/test/testapp.rb

@@ -0,0 +1,64 @@
+# This code is free software; you can redistribute it and/or modify it under the
+# terms of the new BSD License.
+#
+# Copyright (c) 2009, Sebastian Staudt
+
+class RubikonTestApp < Rubikon::Application
+
+  set :autorun, false
+  set :name, 'Rubikon test application'
+  set :raise_errors, true
+
+  default do
+    'default action'
+  end
+
+  action 'input' do
+    input 'input'
+  end
+
+  action_alias :alias_before, :object_id
+
+  action 'object_id' do
+    object_id
+  end
+
+  action_alias :alias_after, :object_id
+
+  action 'noarg' do
+    'noarg action'
+  end
+
+  action 'realnoarg' do ||
+  end
+
+  action 'noarg2' do
+  end
+
+  action 'number_string', :param_type => [Numeric, String] do |s,n|
+  end
+
+  action 'output', :param_type => String do |s|
+    puts s
+    put s
+    putc s[0]
+  end
+
+  action 'required' do |what|
+    "required argument was #{what}"
+  end
+
+  action 'throbber' do |*output|
+    throbber do
+      if output[0]
+        sleep 0.5
+        puts 'don\'t'
+        sleep 0.5
+        puts 'break'
+      else
+        sleep 1
+      end
+    end
+  end
+
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: rubikon
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Sebastian Staudt
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-28 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: A simple to use, yet powerful Ruby framework for building console-based applications.
+email: koraktor@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- LICENSE
+- README.md
+- Rakefile
+- VERSION.yml
+- lib/rubikon.rb
+- lib/rubikon/action.rb
+- lib/rubikon/application.rb
+- lib/rubikon/exceptions.rb
+- test/test.rb
+- test/testapp.rb
+has_rdoc: true
+homepage: http://koraktor.github.com/rubikon
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --all
+- --inline-source
+- --line-numbers
+- --charset=utf-8
+- --webcvs=http://github.com/koraktor/rubikon/blob/master/%s
+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: rubikon
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Rubikon - A Ruby console app framework
+test_files: 
+- test/test.rb
+- test/testapp.rb