rubikon 0.4.1 → 0.5.0

data/README.md

@@ -93,14 +93,15 @@ section if you want to help to make Rubikon better.
 * Automatic checks for option arguments
 * Built-in methods to capture user input
 * Built-in methods to display progress bars and throbbers
+* Built-in support for configuration files
+* Built-in support for colored output
+* Automatic generation of a application help screen
 
 ## Future plans
 
 * User defined type safety of option arguments
-* Automatic generation of help screens
 * Improved error handling
-* Built-in support for configuration files
-* Built-in support for colored output
+* Automatic generation of command help screens
 
 ## Requirements
 

data/lib/core_ext/object.rb

@@ -5,7 +5,8 @@
 
 unless Object.method_defined?(:respond_to_missing?)
 
-  # Extends Ruby's own Object class with method #start_with? for Ruby < 1.9.2
+  # Extends Ruby's own Object class with method #respond_to_missing? for Ruby
+  # < 1.9.2
   #
   # @author Sebastian Staudt
   # @since 0.4.0

data/lib/rubikon.rb

@@ -24,6 +24,6 @@ require 'rubikon/application/base'
 module Rubikon
 
   # This is the current version of the Rubikon gem
-  VERSION = '0.4.1'
+  VERSION = '0.5.0'
 
 end

data/lib/rubikon/application/class_methods.rb

@@ -34,7 +34,11 @@ module Rubikon
       def inherited(subclass)
         subclass.class_eval { include Singleton }
         subclass.send(:base_file=, File.expand_path(caller.first.split(':').first))
-        at_exit { subclass.run if subclass.send(:autorun?) }
+        at_exit do
+          if subclass.send(:autorun?)
+            InstanceMethods.instance_method(:run).bind(subclass.instance).call
+          end
+        end
       end
 
       # This is used for convinience. Method calls on the class itself are

data/lib/rubikon/application/dsl_methods.rb

@@ -19,11 +19,25 @@ module Rubikon
       # @return [String] The (first) definition file of the application
       attr_reader :base_file
 
+      attr_reader :config
+
       # @return [String] The absolute path of the application
       attr_reader :path
 
       private
 
+      # Call another named command with the given arguments
+      #
+      # @param [Symbol] command_name The name of the command to call
+      # @param [Array<String>] args The arguments to pass to the called command
+      # @see Command#run
+      def call(command_name, *args)
+        command = @current_command
+        @current_command = @commands[command_name]
+        @current_command.send(:run, *args)
+        @current_command = command
+      end
+
       # Define a new application Command or an alias to an existing one
       #
       # @param [String, Hash] name The name of the Command as used in
@@ -39,6 +53,8 @@ module Rubikon
       # @return [Command]
       # @since 0.2.0
       def command(name, arg_count = nil, description = nil, &block)
+        command = nil
+
         if name.is_a? Hash
           name.each do |alias_name, command_name|
             command = @commands[command_name]
@@ -63,7 +79,7 @@ module Rubikon
 
         unless command.nil? || @parameters.empty?
           @parameters.each do |parameter|
-            command.add_param(parameter)
+            command.send(:add_param, parameter)
           end
           @parameters.clear
         end
@@ -139,7 +155,7 @@ module Rubikon
         parameter = @global_parameters[name]
         parameter = @current_command.parameters[name] if parameter.nil?
         return false if parameter.nil?
-        parameter.active?
+        parameter.send(:active?)
       end
       alias_method :given?, :active?
 
@@ -365,8 +381,8 @@ module Rubikon
       # @param [String] text The text to write into the output stream
       # @since 0.2.0
       def put(text)
-        @settings[:ostream] << text
-        @settings[:ostream].flush
+        ostream << text
+        ostream.flush
       end
 
       # Output a character using +IO#putc+ of the output stream
@@ -375,7 +391,7 @@ module Rubikon
       #        stream
       # @since 0.2.0
       def putc(char)
-        @settings[:ostream].putc char
+        ostream.putc char
       end
 
       # Output a line of text using +IO#puts+ of the output stream
@@ -383,7 +399,7 @@ module Rubikon
       # @param [String] text The text to write into the output stream
       # @since 0.2.0
       def puts(text)
-        @settings[:ostream].puts text
+        ostream.puts text
       end
 
       # Sets an application setting
@@ -393,20 +409,28 @@ module Rubikon
       # @since 0.2.0
       #
       # Available settings
-      # +autorun+::        If true, let the application run as soon as its
-      #                    class is defined
-      # +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
+      # +autorun+::      If +true+, let the application run as soon as its
+      #                  class is defined. This is generally useful for simple
+      #                  "code and run" applications.
+      # +colors+::       If +true+, enables colored output using ColoredIO
+      # +config_file+::  The name of the config file to search
+      # +config_paths+:: The paths to search for config files
+      # +help_banner+::  Defines a banner for the help message
+      # +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
+        setting = setting.to_sym
+        unless setting == :ostream
+          @settings[setting.to_sym] = value
+        else
+          self.ostream = value
+        end
       end
 
       # Displays a throbber while the given block is executed

data/lib/rubikon/application/instance_methods.rb

@@ -7,7 +7,9 @@ require 'pathname'
 require 'stringio'
 
 require 'rubikon/application/sandbox'
+require 'rubikon/colored_io'
 require 'rubikon/command'
+require 'rubikon/config/factory'
 require 'rubikon/exceptions'
 require 'rubikon/flag'
 require 'rubikon/option'
@@ -50,12 +52,24 @@ module Rubikon
         @sandbox              = Sandbox.new(self)
         @settings             = {
           :autorun         => true,
+          :colors          => true,
+          :config_file     => "#{self.class.to_s.downcase}.yml",
           :help_as_default => true,
           :istream         => $stdin,
           :name            => self.class.to_s,
-          :ostream         => $stdout,
           :raise_errors    => false
         }
+
+	@settings[:config_paths] = []
+        if RUBY_PLATFORM.downcase =~ /mswin(?!ce)|mingw|bccwin/
+          @settings[:config_paths] << ENV['ALLUSERSPROFILE']
+        else
+          @settings[:config_paths] << '/etc'
+        end
+        @settings[:config_paths] << File.expand_path('~')
+        @settings[:config_paths] << File.expand_path('.')
+
+        self.ostream = $stdout
       end
 
       # Run this application
@@ -68,33 +82,38 @@ module Rubikon
       # @param [Array<String>] args The command line arguments that should be
       #        given to the application as options
       def run(args = ARGV)
+        hook = InstanceMethods.instance_method(:hook).bind(self)
+
         begin
-          init
-          command, parameters, args = parse_arguments(args)
+          InstanceMethods.instance_method(:init).bind(self).call
+          command, parameters, args = InstanceMethods.
+            instance_method(:parse_arguments).bind(self).call(args)
 
           parameters.each do |parameter|
             @current_global_param = parameter
-            if parameter.is_a? Option
-              parameter.check_args
-            end
-            parameter.active!
+            parameter.send :check_args if parameter.is_a? Option
+            parameter.send :active!
             @current_global_param = nil
           end
 
+          @config = Config::Factory.new(@settings[:config_file],
+            @settings[:config_paths], @settings[:config_format]).config
+
           @current_command = command
-          hook :pre_execute
-          result = command.run(*args)
-          hook :post_execute
+          hook.call(:pre_execute)
+          result = command.send(:run, *args)
+          hook.call(:post_execute)
           @current_command = nil
 
-          reset
           result
         rescue
           raise $! if @settings[:raise_errors]
 
-          puts "Error:\n    #{$!.message}"
+          puts "r{Error:}\n    #{$!.message}"
           puts "    #{$!.backtrace.join("\n    ")}" if $DEBUG
           exit 1
+        ensure
+          InstanceMethods.instance_method(:reset).bind(self).call
         end
       end
 
@@ -185,13 +204,13 @@ module Rubikon
       # 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
+        current_ostream = ostream
+        self.ostream = StringIO.new
 
         block.call(current_ostream)
 
-        current_ostream << @settings[:ostream].string
-        @settings[:ostream] = current_ostream
+        current_ostream << ostream.string
+        self.ostream = current_ostream
       end
 
       # Executes the hook with the secified name
@@ -199,7 +218,7 @@ module Rubikon
       # @param [Symbol] name The name of the hook to execute
       # @since 0.4.0
       def hook(name)
-        @sandbox.instance_eval &@hooks[name] unless @hooks[name].nil?
+        @sandbox.instance_eval(&@hooks[name]) unless @hooks[name].nil?
       end
 
       # This method is called once for each application and is used to
@@ -209,15 +228,17 @@ module Rubikon
       def init
         return if @initialized
 
+        hook = InstanceMethods.instance_method(:hook).bind(self)
+
         @current_command      = nil
         @current_param        = nil
         @current_global_param = nil
 
-        hook :pre_init
+        hook.call(:pre_init)
 
-        debug_flag
-        help_command
-        verbose_flag
+        InstanceMethods.instance_method(:debug_flag).bind(self).call
+        InstanceMethods.instance_method(:help_command).bind(self).call
+        InstanceMethods.instance_method(:verbose_flag).bind(self).call
 
         if @settings[:help_as_default] && !@commands.keys.include?(:__default)
           default :help
@@ -225,7 +246,7 @@ module Rubikon
 
         @initialized = true
 
-        hook :post_init
+        hook.call(:post_init)
       end
 
       # This is used to determine the receiver of a method call inside the
@@ -247,13 +268,28 @@ module Rubikon
       # @since 0.4.0
       def method_missing(name, *args, &block)
         receiver = @current_param || @current_global_param || @current_command
-        if receiver.nil? || !receiver.respond_to?(name)
+        if receiver.nil? || (!receiver.respond_to?(name) &&
+           !receiver.public_methods(false).include?(name))
           super
         else
           receiver.send(name, *args, &block)
         end
       end
 
+      # Sets the output stream of the application
+      #
+      # If colors are enabled, this checks if the stream supports the
+      # +color_filter+ method and enables the +ColoredIO+ if not.
+      #
+      # @param [IO] ostream The output stream to use
+      # @see ColoredIO.add_color_filter
+      def ostream=(ostream)
+        if !ostream.respond_to?(:color_filter)
+          ColoredIO.add_color_filter(ostream, @settings[:colors])
+        end
+        @settings[:ostream] = ostream
+      end
+
       # Parses the command-line arguments given to the application by the
       # user. This distinguishes between commands, global flags and command
       # flags
@@ -263,16 +299,20 @@ module Rubikon
       #         parameters of this command that have been supplied and any
       #         additional command-line arguments supplied
       def parse_arguments(args)
-        command_arg = args.shift
-        if command_arg.nil? || command_arg.start_with?('-')
+        command_arg = args.find { |arg| arg == '--' || !arg.start_with?('-') }
+        command_arg = nil if command_arg == '--'
+
+        if command_arg.nil?
           command = @commands[:__default]
-          args.unshift(command_arg) unless command_arg.nil?
           raise NoDefaultCommandError if command.nil?
         else
           command = @commands[command_arg.to_sym]
+          args.delete_at args.find_index(command_arg)
           raise UnknownCommandError.new(command_arg) if command.nil?
         end
 
+        args.delete '--'
+
         parameter  = nil
         parameters = []
         args.dup.each do |arg|
@@ -281,7 +321,7 @@ module Rubikon
           elsif arg.start_with?('-')
             parameter = @global_parameters[arg[1..-1].to_sym]
           else
-            if !parameter.nil? && parameter.more_args?
+            if !parameter.nil? && parameter.send(:more_args?)
               parameter.args << args.delete(arg)
             else
               parameter = nil
@@ -300,13 +340,20 @@ module Rubikon
 
       # Resets this application to its initial state
       #
+      # This rewinds the output stream, removes the color features from the and
+      # resets all commands and global parameters.
+      #
+      # @see ColoredIO.remove_color_filter
       # @see Command#reset
       # @see HasArguments#reset
+      # @see IO#rewind
       # @see Parameter#reset
       # @since 0.4.0
       def reset
+        ostream.rewind
+        ColoredIO.remove_color_filter(ostream)
         (@commands.values + @global_parameters.values).uniq.each do |param|
-          param.reset
+          param.send :reset
         end
       end
 

data/lib/rubikon/application/sandbox.rb

@@ -35,11 +35,13 @@ module Rubikon
       #        InstanceMethods and should therefore be protected
       # @see InstanceMethods
       def method_missing(name, *args, &block)
-        if InstanceMethods.method_defined?(name) ||
-           InstanceMethods.private_method_defined?(name)
+        if @__app__.class.instance_methods(false).include?(name.to_s) ||
+           !(InstanceMethods.method_defined?(name) ||
+           InstanceMethods.private_method_defined?(name))
+          @__app__.send(name, *args, &block)
+        else
           raise NoMethodError.new("Method `#{name}' is protected by the application sandbox", name)
         end
-        @__app__.send(name, *args, &block)
       end
 
       # Relay putc to the instance method

data/lib/rubikon/colored_io.rb

@@ -0,0 +1,105 @@
+# This code is free software; you can redistribute it and/or modify it under
+# the terms of the new BSD License.
+#
+# Copyright (c) 2010, Sebastian Staudt
+
+module Rubikon
+
+  # This module is used to enhance an IO stream to generate terminal
+  # color codes from simple text tags.
+  #
+  # @author Sebastian Staudt
+  # @since 0.5.0
+  module ColoredIO
+
+    # Color codes that can be used inside a IO enhanced with ColoredIO
+    COLORS = {
+      :black  => 30,
+      :bl     => 30,
+      :red    => 31,
+      :r      => 31,
+      :green  => 32,
+      :g      => 32,
+      :yellow => 33,
+      :y      => 33,
+      :blue   => 34,
+      :b      => 34,
+      :purple => 35,
+      :p      => 35,
+      :cyan   => 37,
+      :c      => 36,
+      :white  => 37,
+      :w      => 37,
+    }
+
+    # The keys of the color codes joined for the regular expression
+    COLOR_MATCHER = COLORS.keys.join('|')
+
+    # Enables color filtering on the given output stream (or another object
+    # responding to +puts+)
+    #
+    # This wraps the IO's +puts+ method into a call to +color_filter+. The
+    # +color_filter+ method is added dynamically to the singleton class of the
+    # object and does either turn color tags given to the output stream into
+    # their corresponding color code or it simply removes the color tags, if
+    # coloring is disabled.
+    #
+    # @param [IO] io The IO object to add color filtering to
+    # @raise TypeError if the given object does not respond to +puts+
+    # @see .remove_color_filter
+    def self.add_color_filter(io, enabled = true)
+      raise TypeError unless io.respond_to? :puts
+      return if io.respond_to?(:color_filter)
+
+      enabled = enabled && ENV['TERM'] != 'dumb'
+      if enabled && RUBY_PLATFORM.downcase =~ /mswin(?!ce)|mingw|bccwin/
+        begin
+          require 'Win32/Console/ANSI'
+        rescue LoadError 
+          enabled = false
+        end
+      end
+
+      class << io
+        const_set :COLORS, COLORS
+
+        def puts(text = '')
+          super color_filter(text.to_s)
+        end
+      end
+
+      if enabled
+        class << io
+          def color_filter(text)
+            text.gsub(/(#{COLOR_MATCHER})\{(.*?)\}/i) do
+              "\e[0;#{COLORS[$1.downcase.to_sym]}m#{$2}\e[0m"
+            end
+          end
+        end
+      else
+        class << io
+          def color_filter(text)
+            text.gsub(/(#{COLOR_MATCHER})\{(.*?)\}/i, '\2')
+          end
+        end
+      end
+    end
+
+    # Disables color filtering on the given output stream
+    #
+    # This reverts the actions of +add_color_filter+
+    #
+    # @param [IO] io The IO object to remove color filtering from
+    # @see .add_color_filter
+    def self.remove_color_filter(io)
+      return unless io.respond_to?(:color_filter)
+      class << io
+        remove_const  :COLORS
+        remove_method :color_filter
+        remove_method :puts
+      end
+    end
+
+  end
+
+end