rubikon 0.1.0 → 0.2.0

data/README.md

@@ -4,7 +4,7 @@ Rubikon
 Rubikon is a simple to use, yet powerful Ruby framework for building
 console-based applications.
 
-### Installation
+## Installation
 
 You can install Rubikon using RubyGem. This is the easiest way of installing
 and recommended for most users.
@@ -30,7 +30,7 @@ Creating a Rubikon application is as simple as creating a Ruby class:
 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`.
+even more easily by typing `./myapp.rb`.
 
 Now go on and define what your application should do when the user runs it.
 This is done using `default`:

data/Rakefile

@@ -13,8 +13,8 @@ task :default => :test
 
 # Test task
 Rake::TestTask.new do |t|
-  t.libs << 'lib'
-  t.test_files = test_files
+  t.libs << 'lib' << 'test'
+  t.pattern = 'test/**/*_tests.rb'
   t.verbose = true
 end
 

data/VERSION.yml

@@ -1,4 +1,5 @@
----
+--- 
 :major: 0
-:minor: 1
+:minor: 2
 :patch: 0
+:build: 

data/lib/rubikon/action.rb

@@ -9,8 +9,6 @@ module Rubikon
   # 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.
@@ -24,38 +22,43 @@ module Rubikon
     #                 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)
+    def initialize(options = {}, &block)
       raise BlockMissingError unless block_given?
 
-      @name = name
-
       @description = options[:description] || ''
       @param_type = options[:param_type] || Object
 
       @block = block
+      @arg_count = block.arity
     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 MissingArgumentError unless check_argument_count(args.size)
       raise Rubikon::ArgumentTypeError unless check_argument_types(args)
       @block[*args]
     end
 
     private
 
+    # Checks if the number of arguments given fits the number of arguments of
+    # this Action
+    #
+    # +count+:: The number of arguments
+    def check_argument_count(count)
+      !((@arg_count >= 0 && count < @arg_count) || (@arg_count < 0 && count < -@arg_count - 1))
+    end
+
     # 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]
+        args.each_index do |arg_index|
+          return false unless args[arg_index].is_a? @param_type[arg_index]
         end
       else
         args.each do |arg|

data/lib/rubikon/application/base.rb

@@ -0,0 +1,36 @@
+# 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/application/class_methods'
+require 'rubikon/application/instance_methods'
+require 'rubikon/exceptions'
+
+module Rubikon
+
+  version = YAML.load_file(File.join(File.dirname(__FILE__), '..', '..', '..', 'VERSION.yml'))
+  VERSION = "#{version[:major]}.#{version[:minor]}.#{version[:patch]}"
+
+  module Application
+
+    # The main class of Rubikon. Let your own application class inherit from this
+    # one.
+    class Base
+
+      class << self
+        include Rubikon::Application::ClassMethods
+      end
+
+      include Rubikon::Application::InstanceMethods
+      include Singleton
+
+    end
+
+  end
+
+end

data/lib/rubikon/application/class_methods.rb

@@ -0,0 +1,67 @@
+# 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
+
+  module Application
+
+    module ClassMethods
+
+      private
+
+      # Returns whether this application should be ran automatically
+      def autorun?
+        instance.instance_variable_get(:@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 inherited(subclass)
+        super
+        Singleton.__init__(subclass)
+        at_exit { subclass.run if subclass.send(: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 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 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 puts(text)
+        instance.puts text
+      end
+
+    end
+
+  end
+
+end

data/lib/rubikon/application/instance_methods.rb

@@ -0,0 +1,345 @@
+# 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 'rubikon/progress_bar'
+require 'rubikon/throbber'
+
+module Rubikon
+
+  module Application
+
+    module InstanceMethods
+
+      # 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
+        @initialized = false
+        @settings    = {
+          :autorun        => true,
+          :auto_shortopts => 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?
+
+        action = Action.new(options, &block)
+
+        key = name.to_s
+        if @settings[:dashed_options]
+          if @settings[:auto_shortopts]
+            short_key = "-#{key[0..0]}"
+            @actions[short_key.to_sym] = action unless @actions.key? short_key
+          end
+          key = "--#{key}"
+        end
+
+        @actions[key.to_sym] = action
+      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(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
+
+      # Displays a progress bar while the given block is executed
+      #
+      # Inside the block you have access to a instance of ProgressBar. So you
+      # can update the progress using <tt>ProgressBar#+</tt>.
+      #
+      # +options+:: A Hash of options that should be passed to the ProgressBar
+      #             object. For available options see ProgressBar
+      # +block+::   The block to execute
+      #
+      # Example:
+      #
+      #  progress_bar(:maximum => 5) do |progress|
+      #    5.times do |file|
+      #      File.read("any#{file}.txt")
+      #      progress.+
+      #    end
+      #  end
+      def progress_bar(*options, &block)
+        hidden_output do |ostream|
+          options = options[0]
+          options[:ostream] = ostream
+
+          progress = ProgressBar.new(options)
+
+          block.call(progress)
+        end
+      end
+
+      # Output text using +IO#<<+ of the output stream
+      #
+      # +text+:: The text to write into the output stream
+      def put(text)
+        @settings[:ostream] << text
+        @settings[: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)
+        @settings[: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)
+        @settings[: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)
+        init unless @initialized
+        action_results = []
+
+        begin
+          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
+          raise $! if @settings[:raise_errors]
+
+          puts "Error:\n    #{$!.message}"
+          puts "    #{$!.backtrace.join("\n    ")}" if $DEBUG
+          exit 1
+        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)
+        hidden_output do |ostream|
+          code_thread = Thread.new { block.call }
+          throbber_thread = Throbber.new(ostream, code_thread)
+
+          code_thread.join
+          throbber_thread.join
+        end
+      end
+
+      private
+
+      # 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
+      end
+
+      # Defines an action for displaying a help screen
+      #
+      # This takes any defined action and it's corresponding options and
+      # descriptions and displays them in a user-friendly manner.
+      def help_action
+        action 'help', { :description => 'Display this help screen' } do
+          help = {}
+          @actions.each do |option, action|
+            help[action] = [] if help[action].nil?
+            help[action] << option.to_s
+          end
+
+          put @settings[:help_banner]
+          puts " [options]" unless @default.nil?
+          puts ''
+
+          help.each do |action, options|
+            help[action] = options.sort.join(', ')
+          end
+          max_options_length = help.values.max { |a,b| a.size <=> b.size }.size
+          help.sort_by { |action, options| options }.each do |action, options|
+            puts options.ljust(max_options_length) << "    " << action.description
+          end
+        end
+      end
+
+      # Hide output inside the given block and print it after the block has
+      # finished
+      #
+      # +block+:: The block that should not print output while it's running
+      #
+      # If the block needs to print to the real IO stream, it can access it
+      # using its first parameter.
+      def hidden_output(&block)
+        current_ostream = @settings[:ostream]
+        @settings[:ostream] = StringIO.new
+
+        block.call(current_ostream)
+
+        current_ostream << @settings[:ostream].string
+        @settings[:ostream] = current_ostream
+      end
+
+      # This method is called once for each application and is used to
+      # initialize anything that needs to be ready before the application is
+      # run, but <em>after</em> the application is setup, i.e. after the user
+      # has defined the application class.
+      def init
+        help_action
+        assign_aliases
+        @initialized = true
+      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_s.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
+
+end

data/lib/rubikon/progress_bar.rb

@@ -0,0 +1,69 @@
+# 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
+
+  # A class for displaying and managing progress bars
+  class ProgressBar
+
+    # Create a new ProgressBar using the given options.
+    #
+    # +ostream+:: The output stream where the progress bar should be displayed
+    # +options+:: An Hash of options to customize the progress bar
+    #
+    # Options:
+    #
+    # +char+::    The character used for progress bar display (default: +#+)
+    # +maximum+:: The maximum value of this progress bar (default: +100+)
+    # +size+::    The actual size of the progress bar (default: +20+)
+    # +start+::   The start value of the progress bar (default: +0+)
+    def initialize(options = {})
+      if options.is_a? Numeric
+        @maximum = options
+        options = {}
+      else
+        @maximum = options[:maximum] || 100
+      end
+      @maximum.round
+
+      @progress_char = options[:char] || '#'
+      @factor   = (options[:size] || 20).round.to_f / @maximum
+      @ostream  = options[:ostream] || $stdout
+      @progress = 0
+      @value    = 0
+
+      self + (options[:start] || 0)
+    end
+
+    # Add an amount to the current value of the progress bar
+    #
+    # This triggers a refresh of the progress bar, if the added value actually
+    # changes the displayed bar.
+    #
+    # Example:
+    #
+    #  progress_bar + 1 # (will add 1)
+    #  progress_bar + 5 # (will add 5)
+    #  progress_bar.+   # (will add 1)
+    def +(value = 1)
+      return if value <= 0
+      value = value.round
+      old_progress = @progress
+      @value += value
+      add_progress = (value * @factor).round
+      @progress += add_progress
+
+      @progress = 100 if @progress > 100
+
+      difference = @progress - old_progress
+      if difference > 0 && @progress <= @maximum
+        @ostream << @progress_char * difference
+        @ostream.flush
+      end
+    end
+
+  end
+
+end

data/lib/rubikon/setter.rb

@@ -0,0 +1,17 @@
+# 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 Setter < Action
+
+    def run(*args)
+      
+      super
+    end
+
+  end
+
+end

data/lib/rubikon/throbber.rb

@@ -0,0 +1,36 @@
+# 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
+
+  # A class for displaying and managing throbbers
+  class Throbber < Thread
+
+    SPINNER = '-\|/'
+
+    # Creates and runs a Throbber that outputs to the given IO stream while the
+    # given thread is alive
+    #
+    # # +ostream+:: The IO stream the throbber should be written to
+    # +thread+::  The thread that should be watched
+    def initialize(ostream, thread)
+      proc = Proc.new do |ostream, thread|
+          step = 0
+          ostream.putc 32
+          while thread.alive?
+            ostream << "\b#{SPINNER[step].chr}"
+            ostream.flush
+            step = (step + 1) % 4
+            sleep 0.25
+          end
+        ostream.putc 8
+      end
+
+      super { proc.call(ostream, thread) }
+    end
+
+  end
+
+end

data/lib/rubikon.rb

@@ -6,4 +6,4 @@
 libdir = File.dirname(__FILE__)
 $:.unshift(libdir) unless $:.include?(libdir)
 
-require 'rubikon/application'
+require 'rubikon/application/base'

data/test/action_tests.rb

@@ -0,0 +1,36 @@
+# 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 'test_helper'
+
+class ActionTests < Test::Unit::TestCase
+
+  context 'A Rubikon action' do
+
+    should 'throw an exception when no code block is given' do
+      assert_raise Rubikon::BlockMissingError do
+        Rubikon::Action.new
+      end
+      assert_raise Rubikon::BlockMissingError do
+        options = {}
+        Rubikon::Action.new options
+      end
+    end
+
+    should 'not raise an exception when created without options' do
+      action_options = {
+        :description => 'this is an action',
+        :param_type  => String
+      }
+      assert_nothing_raised do
+        action = Rubikon::Action.new action_options do end
+        assert_equal action_options[:description], action.description
+        assert_equal action_options[:param_type], action.param_type
+      end
+    end
+
+  end
+
+end

data/test/{test.rb → application_tests.rb}

@@ -3,17 +3,10 @@
 #
 # 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 'test_helper'
 require 'testapp'
 
-class RubikonTests < Test::Unit::TestCase
+class ApplicationTests < Test::Unit::TestCase
 
   context 'A Rubikon application\'s class' do
 
@@ -21,6 +14,12 @@ class RubikonTests < Test::Unit::TestCase
       @app = RubikonTestApp.instance
     end
 
+    should 'be a singleton' do
+      assert_raise NoMethodError do
+        RubikonTestApp.new
+      end
+    end
+
     should 'run it\'s instance for called methods' do
       assert_equal @app.run(%w{--object_id}), RubikonTestApp.run(%w{--object_id})
     end
@@ -34,12 +33,6 @@ class RubikonTests < Test::Unit::TestCase
       @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
@@ -56,7 +49,7 @@ class RubikonTests < Test::Unit::TestCase
     end
 
     should 'run it\'s default action without options' do
-      result = @app.run
+      result = @app.run([])
       assert_equal 1, result.size
       assert_equal 'default action', result.first
     end
@@ -143,31 +136,4 @@ class RubikonTests < Test::Unit::TestCase
 
   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/progress_bar_tests.rb

@@ -0,0 +1,95 @@
+# 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 'test_helper'
+
+class ProgressBarTests < Test::Unit::TestCase
+
+  context 'A progress bar' do
+
+    should 'have default settings' do
+      @bar = Rubikon::ProgressBar.new
+      assert_equal 0.2,     @bar.instance_variable_get(:@factor)
+      assert_equal 100,     @bar.instance_variable_get(:@maximum)
+      assert_equal $stdout, @bar.instance_variable_get(:@ostream)
+      assert_equal 0,       @bar.instance_variable_get(:@progress)
+      assert_equal '#',     @bar.instance_variable_get(:@progress_char)
+      assert_equal 0,       @bar.instance_variable_get(:@value)
+    end
+
+    should 'be customizable' do
+      options = {
+        :char    => '+',
+        :maximum => 10,
+        :ostream => StringIO.new,
+        :size    => 100,
+        :start   => 5
+      }
+      @bar = Rubikon::ProgressBar.new(options)
+      assert_equal options[:size].to_f / options[:maximum], @bar.instance_variable_get(:@factor)
+      assert_equal options[:maximum], @bar.instance_variable_get(:@maximum)
+      assert_equal options[:ostream], @bar.instance_variable_get(:@ostream)
+      assert_equal options[:start].to_f / options[:maximum] * options[:size], @bar.instance_variable_get(:@progress)
+      assert_equal options[:char], @bar.instance_variable_get(:@progress_char)
+      assert_equal options[:start], @bar.instance_variable_get(:@value)
+    end
+
+    should 'draw correctly for different sizes' do
+      ostream = StringIO.new
+      options = { :ostream => ostream, :start => 50 }
+
+      @bar = Rubikon::ProgressBar.new(options)
+      assert_equal "#" * 10, ostream.string
+      @bar + 50
+      assert_equal "#" * 20, ostream.string
+
+      ostream.string = ''
+      options[:size] = 10
+
+      @bar = Rubikon::ProgressBar.new(options)
+      assert_equal "#" * 5, ostream.string
+      @bar + 10
+      assert_equal "#" * 6, ostream.string
+
+      ostream.string = ''
+      options[:size] = 100
+
+      @bar = Rubikon::ProgressBar.new(options)
+      assert_equal "#" * 50, ostream.string
+      @bar + 30
+      assert_equal "#" * 80, ostream.string
+    end
+
+    should 'not overflow' do
+      ostream = StringIO.new
+      options = { :ostream => ostream, :size => 100 }
+
+      @bar = Rubikon::ProgressBar.new options
+      @bar + 101
+      assert_equal "#" * 100, ostream.string
+      assert_equal 100, @bar.instance_variable_get(:@progress)
+      assert_equal 101, @bar.instance_variable_get(:@value)
+
+      ostream.string = ''
+      options[:start] = 50
+
+      @bar = Rubikon::ProgressBar.new options
+      @bar + 51
+      assert_equal "#" * 100, ostream.string
+      assert_equal 100, @bar.instance_variable_get(:@progress)
+      assert_equal 101, @bar.instance_variable_get(:@value)
+
+      ostream.string = ''
+      options[:start] = 101
+      
+      @bar = Rubikon::ProgressBar.new options
+      assert_equal "#" * 100, ostream.string
+      assert_equal 100, @bar.instance_variable_get(:@progress)
+      assert_equal 101, @bar.instance_variable_get(:@value)
+    end
+
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,16 @@
+# 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
+
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+$: << File.dirname(__FILE__)
+require 'rubikon'
+include Rubikon
+
+require 'rubygems'
+require 'shoulda'
+
+unless RUBY_VERSION[0..2] == '1.9'
+  begin require 'redgreen'; rescue LoadError; end
+end

data/test/testapp.rb

@@ -3,7 +3,7 @@
 #
 # Copyright (c) 2009, Sebastian Staudt
 
-class RubikonTestApp < Rubikon::Application
+class RubikonTestApp < Rubikon::Application::Base
 
   set :autorun, false
   set :name, 'Rubikon test application'

data/test/throbber_tests.rb

@@ -0,0 +1,23 @@
+# 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 'test_helper'
+
+class ThrobberTests < Test::Unit::TestCase
+
+  context 'A throbber' do
+
+    should 'be a subclass of Thread' do
+      assert_equal Thread, Rubikon::Throbber.superclass
+    end
+
+    should 'have default throbber strings' do
+      assert_equal %w{SPINNER}, Throbber.constants
+      assert_equal '-\|/', Rubikon::Throbber.const_get(:SPINNER)
+    end
+
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rubikon
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Sebastian Staudt
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-28 00:00:00 +01:00
+date: 2009-11-07 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -29,10 +29,19 @@ files:
 - VERSION.yml
 - lib/rubikon.rb
 - lib/rubikon/action.rb
-- lib/rubikon/application.rb
+- lib/rubikon/application/base.rb
+- lib/rubikon/application/class_methods.rb
+- lib/rubikon/application/instance_methods.rb
 - lib/rubikon/exceptions.rb
-- test/test.rb
+- lib/rubikon/progress_bar.rb
+- lib/rubikon/setter.rb
+- lib/rubikon/throbber.rb
+- test/action_tests.rb
+- test/application_tests.rb
+- test/progress_bar_tests.rb
+- test/test_helper.rb
 - test/testapp.rb
+- test/throbber_tests.rb
 has_rdoc: true
 homepage: http://koraktor.github.com/rubikon
 licenses: []
@@ -66,5 +75,9 @@ signing_key:
 specification_version: 3
 summary: Rubikon - A Ruby console app framework
 test_files: 
-- test/test.rb
+- test/action_tests.rb
+- test/application_tests.rb
+- test/progress_bar_tests.rb
+- test/test_helper.rb
 - test/testapp.rb
+- test/throbber_tests.rb

data/lib/rubikon/application.rb

@@ -1,331 +0,0 @@
-# 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