ronin 1.3.0 → 1.4.0.rc1

data/lib/ronin/script/exceptions.rb

@@ -19,5 +19,6 @@
 
 require 'ronin/script/exceptions/exception'
 require 'ronin/script/exceptions/not_built'
+require 'ronin/script/exceptions/build_failed'
 require 'ronin/script/exceptions/test_failed'
 require 'ronin/script/exceptions/deploy_failed'

data/lib/ronin/script/exceptions/build_failed.rb

@@ -0,0 +1,27 @@
+#
+# Copyright (c) 2006-2011 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# This file is part of Ronin.
+#
+# Ronin is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ronin is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ronin.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+require 'ronin/script/exceptions/exception'
+
+module Ronin
+  module Script
+    class BuildFailed < Exception
+    end
+  end
+end

data/lib/ronin/script/path.rb

@@ -18,7 +18,6 @@
 #
 
 require 'ronin/model'
-require 'ronin/repository'
 require 'ronin/script/script'
 require 'ronin/support/inflector'
 
@@ -231,10 +230,8 @@ module Ronin
           # destroy the cached file, if the actual file is missing
           return destroy
         elsif updated?
-          if (script = cached_script)
-            # destroy the previously cached object
-            script.destroy!
-          end
+          # clean the previously cached file
+          clean
 
           # if we couldn't cache anything, self-destruct
           destroy unless cache
@@ -244,6 +241,18 @@ module Ronin
         return false
       end
 
+      #
+      # Cleans the cached file from the Database.
+      #
+      # @since 1.4.0
+      #
+      def clean
+        if (script = cached_script)
+          # destroy the previously cached object
+          script.destroy!
+        end
+      end
+
       #
       # Before destroying the cached file object, also destroy the
       # associated cached object.
@@ -251,13 +260,21 @@ module Ronin
       # @since 1.1.0
       #
       def destroy
-        unless destroyed?
-          if (script = cached_script)
-            script.destroy!
-          end
-        end
+        clean unless destroyed?
+
+        return super
+      end
+
+      #
+      # Before forcibly destroying the cached file object, also destroy the
+      # associated cached object.
+      #
+      # @since 1.4.0
+      #
+      def destroy!
+        clean unless destroyed?
 
-        super
+        return super
       end
 
       #

data/lib/ronin/script/script.rb

@@ -83,6 +83,9 @@ module Ronin
 
         # The cached file of the object
         belongs_to :script_path, Ronin::Script::Path, :required => false
+
+        # Validations
+        validates_uniqueness_of :version, :scope => [:name]
       end
 
       Path.has 1, base.relationship_name, base, :child_key => [:script_path_id]
@@ -92,6 +95,20 @@ module Ronin
     # @since 1.1.0
     #
     module ClassMethods
+      #
+      # The shortened name of the Script class.
+      #
+      # @return [String]
+      #   The shortened name.
+      #
+      # @since 1.4.0
+      #
+      # @api semipublic
+      #
+      def short_name
+        @short_name ||= self.name.split('::').last
+      end
+
       #
       # Loads the {Script} of the same class.
       #
@@ -177,20 +194,6 @@ module Ronin
         super(*arguments,&block)
       end
 
-      #
-      # The script type.
-      #
-      # @return [String]
-      #   The name of the script class.
-      #
-      # @since 1.1.0
-      #
-      # @api semipublic
-      #
-      def script_type
-        @script_type ||= self.class.base_model.name.split('::').last
-      end
-
       #
       # Determines if the original code, from the cache file, has been
       # loaded into the object.

data/lib/ronin/script/testable.rb

@@ -50,7 +50,7 @@ module Ronin
       # Tests that the script is properly configured.
       #
       # @return [true]
-      #   The exploit is built and ready for deployment.
+      #   The script is built and ready for deployment.
       #
       # @see test
       #
@@ -59,11 +59,11 @@ module Ronin
       # @api semipublic
       #
       def test!
-        print_info "Testing #{script_type} ..."
+        print_info "Testing #{self.class.short_name} ..."
 
         @test_blocks.each { |block| block.call() }
 
-        print_info "#{script_type} tested!"
+        print_info "#{self.class.short_name} tested!"
         return true
       end
 

data/lib/ronin/service.rb

@@ -19,7 +19,6 @@
 
 require 'ronin/model'
 require 'ronin/model/has_unique_name'
-require 'ronin/open_port'
 
 module Ronin
   #

data/lib/ronin/service_credential.rb

@@ -18,7 +18,6 @@
 #
 
 require 'ronin/credential'
-require 'ronin/open_port'
 
 module Ronin
   #

data/lib/ronin/software.rb

@@ -18,7 +18,6 @@
 #
 
 require 'ronin/model'
-require 'ronin/vendor'
 
 module Ronin
   #

data/lib/ronin/target.rb

@@ -18,8 +18,6 @@
 #
 
 require 'ronin/model'
-require 'ronin/campaign'
-require 'ronin/address'
 
 require 'dm-timestamps'
 require 'fileutils'

data/lib/ronin/tcp_port.rb

@@ -18,7 +18,6 @@
 #
 
 require 'ronin/port'
-require 'ronin/url'
 
 module Ronin
   #

data/lib/ronin/ui/cli/class_command.rb

@@ -0,0 +1,130 @@
+#
+# Copyright (c) 2006-2011 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# This file is part of Ronin.
+#
+# Ronin is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ronin is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Ronin.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+require 'ronin/ui/cli/command'
+
+require 'parameters'
+
+module Ronin
+  module UI
+    module CLI
+      #
+      # @since 1.4.0
+      #
+      class ClassCommand < Command
+
+        # The object created from the Class
+        attr_reader :object
+
+        def initialize(options={})
+          super(options)
+
+          unless self.class.command_class < Parameters
+            raise(TypeError,"#{command_class} does not include Parameters")
+          end
+
+          @object = self.class.command_class.new()
+          @object.params = options
+        end
+
+        protected
+
+        #
+        # Sets or gets the class namespace.
+        #
+        # @param [Module, nil] new_namespace
+        #   The namespace to load the class from.
+        #
+        # @return [Module]
+        #   The namespace that the class resides in.
+        #
+        # @api semipublic
+        #
+        def self.class_namespace(new_namespace=nil)
+          if new_namespace
+            @class_namespace = new_namespace
+          else
+            @class_namespace ||= if superclass < ClassCommand
+                                   superclass.class_namespace
+                                 end
+          end
+        end
+
+        #
+        # Sets or gets the class name.
+        #
+        # @param [Symbol, nil] name
+        #   The class name to load from the namespace.
+        #
+        # @return [Symbol]
+        #   The class name.
+        #
+        # @api semipublic
+        #
+        def self.class_name(name=nil)
+          if name
+            @class_name = name.to_sym
+          else
+            @class_name ||= self.name.split('::').last.to_sym
+          end
+        end
+
+        #
+        # The loaded class from the namespace.
+        #
+        # @return [Class]
+        #   The loaded class.
+        #
+        # @api semipublic
+        #
+        def self.command_class
+          @command_class ||= class_namespace.const_get(class_name)
+        end
+
+        #
+        # Creates an OptionParser for the class command.
+        #
+        # @yield [opts]
+        #   The given block will be passed the newly created OptionParser,
+        #   after options for the class have been defined.
+        #
+        # @yieldparam [OptionParser] opts
+        #   The newly created OptionParser.
+        #
+        # @return [OptionParser]
+        #   The fully configured OptionParser.
+        #
+        # @since 1.4.0
+        #
+        # @api semipublic
+        #
+        def option_parser
+          super do |opts|
+            @object.each_param do |param|
+              Parameters::Options.define(opts,param)
+            end
+
+            yield opts if block_given?
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/ronin/ui/cli/command.rb

@@ -17,19 +17,18 @@
 # along with Ronin.  If not, see <http://www.gnu.org/licenses/>.
 #
 
+require 'ronin/ui/cli/printing'
 require 'ronin/ui/output'
-require 'ronin/ui/output/terminal'
 require 'ronin/support/inflector'
 
-require 'thor'
-require 'thor/group'
+require 'parameters'
+require 'parameters/options'
 
 module Ronin
   module UI
     module CLI
       #
-      # The {Command} class inherits `Thor::Group` to provide a base-class
-      # for defining commands for the {CLI}.
+      # The {Command} provides a base-class for defining commands for the {CLI}.
       #
       # # Extending
       #
@@ -45,29 +44,41 @@ module Ronin
       #           module Commands
       #             class MyCommand < Command
       #
-      #               desc 'My command'
+      #               summary 'My command'
       #
-      #               # command options
-      #               class_option :stuff, :type => :boolean
-      #               class_option :syntax, :type => :string
-      #               class_option :includes, :type => :array
+      #               option :enable, :type => true,
+      #                               :flag => '-e',
+      #                               :description => 'Enables stuff'
+      #
+      #               option :syntax, :type => Symbol,
+      #                               :flag => '-S',
+      #                               :description => 'Syntax to use'
+      #
+      #               option :includes, :type    => Array[String],
+      #                                 :default => [],
+      #                                 :flag    => '-I',
+      #                                 :usage   => 'FILE [...]',
+      #                                 :description => 'Files to include'
+      #
+      #               option :params, :type => Hash[Symbol => Object],
+      #                               :flag => '-P',
+      #                               :description => 'Additional params'
       #
-      #               # command arguments
       #               argument :path
       #
       #               #
       #               # Executes the command.
       #               #
       #               def execute
-      #                 print_info "Stuff enabled" if options.stuff?
+      #                 print_info "Stuff enabled" if enable?
       #
-      #                 if options[:syntax]
-      #                   print_info "Using syntax #{options[:syntax]}"
+      #                 if syntax?
+      #                   print_info "Using syntax #{@syntax}"
       #                 end
       #
-      #                 if options[:includes]
+      #                 if includes?
       #                   print_info "Including:"
-      #                   print_array options[:includes]
+      #                   print_array @includes
       #                 end
       #               end
       #
@@ -79,14 +90,6 @@ module Ronin
       #
       # # Running
       #
-      # To run the command from Ruby, one can call the {run} class method
-      # with the options and arguments to run the command with:
-      #
-      #     MyCommand.run(
-      #       {:stuff => true, :syntax => 'bla', :includes => ['other']},
-      #       ['some/file.txt']
-      #     )
-      #
       # To run the command from Ruby, with raw command-line options, one
       # can call the `start` class method:
       #
@@ -110,33 +113,23 @@ module Ronin
       #     ronin my_command some/file.txt --stuff --syntax bla \
       #       --includes one two
       #
-      class Command < Thor::Group
-
-        include Thor::Actions
-        include Output::Helpers
+      class Command
 
-        class_option :verbose, :type => :boolean,
-                               :default => false,
-                               :aliases => '-v'
-        class_option :quiet, :type => :boolean,
-                             :default => false,
-                             :aliases => '-q'
-        class_option :silent, :type => :boolean,
-                              :default => false,
-                              :aliases => '-Q'
-
-        class_option :color, :type => :boolean, :default => true
+        include Parameters
+        include Printing
 
         #
-        # Sets the namespace of a new {Command} class.
+        # Initializes the command object.
         #
-        # @param [Class] super_class
-        #   The new {Command} class.
+        # @param [Hash{Symbol => Object}] options
+        #   Options for the command.
         #
-        # @api private
+        # @api semipublic
         #
-        def self.inherited(super_class)
-          super_class.namespace(super_class.command_name)
+        def initialize(options={})
+          super()
+
+          initialize_params(options)
         end
 
         #
@@ -145,75 +138,122 @@ module Ronin
         # @api semipublic
         #
         def self.command_name
-          Support::Inflector.underscore(self.name.split('::').last)
+          @command_name ||= Support::Inflector.underscore(
+            self.name.sub('Ronin::UI::CLI::Commands::','').gsub('::',':')
+          )
         end
 
         #
         # Runs the command.
         #
-        # @param [Hash{String,Symbol => Object}] options
-        #   Option values for the command.
+        # @param [Array<String>] argv
+        #   The arguments for the command to parse.
         #
-        # @param [Array<String>] arguments
-        #   Additional arguments for the command.
+        # @return [true]
+        #   Specifies that the command successfully executed.
         #
-        # @return [Command]
-        #   The executed command.
+        # @note
+        #   If the command raises an Exception, the process will exit with
+        #   status code `-1`.
         #
         # @since 1.0.0
         #
         # @api public
         #
-        def self.run(options={},arguments=[])
-          command = self.new(arguments,options)
+        def self.start(argv=ARGV)
+          command = new()
+
+          unless command.start(argv)
+            exit -1
+          end
 
-          command.invoke_all()
-          return command
+          return true
         end
 
         #
-        # Creates a new Command object.
+        # Runs the command with the given options.
         #
-        # @param [Array] arguments
-        #   Command-line arguments.
+        # @param [Hash{Symbol => Object}] options
+        #   Options for the command.
         #
-        # @param [Array] opts
-        #   Additional command-line options.
+        # @return [true]
+        #   Specifies that the command successfully executed.
         #
-        # @param [Hash] config
-        #   Additional configuration.
+        # @raise [Exception]
+        #   An exception raised within the command.
         #
-        # @api semipublic
+        # @api public
         #
-        def initialize(arguments=[],opts={},config={})
-          @indent = 0
-
-          super(arguments,opts,config)
-          setup
+        def self.run(options={})
+          command = new()
+          
+          return command.run(options)
         end
 
         #
-        # Default method to call after the options have been parsed.
+        # Starts the command with the given command-line arguments.
+        #
+        # @param [Array<String>] argv
+        #   The given command-line arguments.
+        #
+        # @return [true]
+        #   Specifies whether the command executed successfully.
+        #
+        # @note
+        #   If the command raises an Exception, the process will exit with
+        #   status code `-1`.
+        #
+        # @since 1.4.0
         #
         # @api semipublic
         #
-        def execute
-        end
+        def start(argv=ARGV)
+          arguments = option_parser.parse(argv)
 
-        protected
+          # set additional arguments
+          self.class.each_argument do |name|
+            param = get_param(name)
+
+            if param.type <= Parameters::Types::Array
+              # allow Array/Set arguments to collect all remaining args
+              param.value = arguments.shift(arguments.length)
+            else
+              param.value = arguments.shift
+            end
+          end
+
+          begin
+            run
+          rescue => error
+            print_exception(error)
+            exit -1
+          end
+
+          return true
+        end
 
         #
-        # The banner for the command.
+        # Sets up and executes the command.
         #
-        # @return [String]
-        #   The banner string.
+        # @param [Hash{Symbol => Object}] options
+        #   Additional options to run the command with.
         #
-        # @since 1.0.0
+        # @return [true]
+        #   Specifies that the command exited successfully.
         #
-        # @api private
+        # @see #setup
+        # @see #execute
         #
-        def self.banner
-          "ronin #{self_task.formatted_usage(self,false,true)}"
+        # @since 1.4.0
+        #
+        # @api semipublic
+        #
+        def run(options={})
+          self.params = options
+
+          setup
+          execute
+          return true
         end
 
         #
@@ -224,11 +264,11 @@ module Ronin
         # @api semipublic
         #
         def setup
-          Output.verbose! if self.options.verbose?
-          Output.quiet! if self.options.quiet?
-          Output.silent! if self.options.silent?
+          Output.verbose! if verbose?
+          Output.quiet!   if quiet?
+          Output.silent!  if silent?
 
-          Output.handler = if self.options.color?
+          Output.handler = if color?
                              Output::Terminal::Color
                            else
                              Output::Terminal::Raw
@@ -236,145 +276,290 @@ module Ronin
         end
 
         #
-        # Increases the indentation out output temporarily.
+        # Default method to call after the options have been parsed.
         #
-        # @param [Integer] n
-        #   The number of spaces to increase the indentation by.
+        # @api semipublic
         #
-        # @yield []
-        #   The block will be called after the indentation has been
-        #   increased. After the block has returned, the indentation will
-        #   be returned to normal.
+        def execute
+        end
+
+        protected
+
+        #
+        # The usage for the command.
+        #
+        # @param [String] new_usage
+        #   The new usage for the command.
+        #
+        # @return [String]
+        #   The usage string.
         #
-        # @return [nil]
+        # @since 1.4.0
         #
         # @api semipublic
         #
-        def indent(n=2)
-          @indent += n
-
-          yield
-
-          @indent -= n
-          return nil
+        def self.usage(new_usage=nil)
+          if new_usage
+            @usage = new_usage
+          else
+            @usage ||= if superclass < Command
+                         superclass.usage
+                       else
+                         '[options]'
+                       end
+          end
         end
 
         #
-        # Print the given messages with indentation.
+        # The summary for the command.
         #
-        # @param [Array] messages
-        #   The messages to print, one per-line.
+        # @param [String] new_summary
+        #   The new summary for the command.
+        #
+        # @return [String]
+        #   The summary string.
+        #
+        # @since 1.4.0
         #
         # @api semipublic
         #
-        def puts(*messages)
-          super(*(messages.map { |mesg| (' ' * @indent) + mesg.to_s }))
+        def self.summary(new_summary=nil)
+          if new_summary
+            @summary = new_summary
+          else
+            @summary ||= if superclass < Command
+                           superclass.summary
+                         end
+          end
         end
 
         #
-        # Prints a given title.
+        # The options for the parameters.
         #
-        # @param [String] title
-        #   The title to print.
+        # @return [Hash{Symbol => Hash}]
+        #   The banner string.
+        #
+        # @since 1.4.0
         #
         # @api semipublic
         #
-        def print_title(title)
-          puts "[ #{title} ]\n"
+        def self.options
+          @options ||= {}
         end
 
         #
-        # Prints a section with a title.
+        # Defines an option for the command.
         #
-        # @yield []
-        #   The block will be called after the title has been printed
-        #   and indentation increased.
+        # @param [Symbol] name
+        #   The name of the option.
         #
-        # @since 1.0.0
+        # @param [Hash] options
+        #   Additional options for the option.
+        #
+        # @option options [Hash{Class => Class}, Set<Class>, Array<Class>, Class, true] :type (String)
+        #   The type of the options.
+        #
+        # @option options [Object, Proc] :default
+        #   The default value for the options.
+        #
+        # @option options [String] :flag
+        #   The short-flag for the option.
+        #
+        # @option options [String] :usage
+        #   The usage for the option.
+        #
+        # @option options [String] :description
+        #   The description of the option.
+        #
+        # @return [Parameters::ClassParam]
+        #   The parameter that will contain the value of the option.
+        #
+        # @example
+        #   option :output, :type        => String,
+        #                   :flag        => '-f',
+        #                   :usage       => 'PATH',
+        #                   :description => 'The path to write the output to'
+        #
+        # @since 1.4.0
         #
         # @api semipublic
         #
-        def print_section(title,&block)
-          print_title(title)
-          indent(&block)
+        def self.option(name,options={})
+          options = {:type => String}.merge(options)
+
+          self.options[name] = {
+            :flag  => options[:flag],
+            :usage => options[:usage],
+          }
+
+          return parameter(name,options)
         end
 
+        option :verbose, :type        => true,
+                         :flag        => '-v',
+                         :description => 'Enable verbose output'
+
+        option :quiet, :type        => true,
+                       :flag        => '-q',
+                       :description => 'Disable verbose output'
+
+        option :silent, :type         => true,
+                        :description  => 'Silence all output'
+
+        option :color, :type        => true,
+                       :default     => proc { !$stdout.tty? },
+                       :description => 'Enables color output'
+
         #
-        # Prints a given Array.
+        # Enumerates through the options define by every sub-class.
         #
-        # @param [Array] array 
-        #   The Array to print.
+        # @yield [name,options]
+        #   The given block will be passed each option.
         #
-        # @param [Hash] options
-        #   Additional options.
+        # @yieldparam [Symbol] name
+        #   The name of the option.
         #
-        # @option options [String] :title
-        #   The optional title to print before the contents of the Array.
+        # @yieldparam [Hash] options
+        #   Additional options associated with the option.
         #
-        # @return [nil]
+        # @return [Enumerator]
+        #   If no block is given, an Enumerator will be returned.
         #
-        # @api semipublic
+        # @since 1.4.0
+        #
+        # @api private
         #
-        def print_array(array,options={})
-          print_title(options[:title]) if options[:title]
+        def self.each_option(&block)
+          return enum_for(:each_option) unless block
 
-          indent do
-            array.each { |value| puts value }
+          ancestors.reverse_each do |ancestor|
+            if ancestor <= Command
+              ancestor.options.each(&block)
+            end
           end
+        end
 
-          puts if options[:title]
-          return nil
+        #
+        # The additional arguments of the command.
+        #
+        # @return [Array<Symbol>]
+        #   The names of the arguments.
+        #
+        # @since 1.4.0
+        #
+        # @api semipublic
+        #
+        def self.arguments
+          @arguments ||= []
         end
 
         #
-        # Prints a given Hash.
+        # Defines an argument for the command.
         #
-        # @param [Hash] hash
-        #   The Hash to print.
+        # @param [Symbol] name
+        #   The name of the argument.
         #
         # @param [Hash] options
-        #   Additional options.
+        #   Additional options for the argument.
+        #
+        # @option options [Hash{Class => Class}, Set<Class>, Array<Class>, Class, true] :type (String)
+        #   The type of the argument.
+        #
+        # @option options [Object, Proc] :default
+        #   The default value for the argument.
+        #
+        # @return [Parameters::ClassParam]
+        #   The parameter that will contain the value of the argument.
         #
-        # @option options [String] :title
-        #   The optional title to print before the contents of the Hash.
+        # @example
+        #   argument :file, :type        => String,
+        #                   :description => "The file to process"
         #
-        # @return [nil]
+        # @since 1.4.0
         #
         # @api semipublic
         #
-        def print_hash(hash,options={})
-          align = hash.keys.map { |name|
-            name.to_s.length
-          }.max
+        def self.argument(name,options={})
+          self.arguments << name.to_sym
 
-          print_title(options[:title]) if options[:title]
+          return parameter(name,options)
+        end
 
-          indent do
-            hash.each do |name,value|
-              name = "#{name}:".ljust(align)
-              puts "#{name}\t#{value}"
+        #
+        # Enumerates through the arguments define by every sub-class.
+        #
+        # @yield [name]
+        #   The given block will be passed each argument name.
+        #
+        # @yieldparam [Symbol] name
+        #   The name of the argument.
+        #
+        # @return [Enumerator]
+        #   If no block is given, an Enumerator will be returned.
+        #
+        # @since 1.4.0
+        #
+        # @api private
+        #
+        def self.each_argument(&block)
+          return enum_for(:each_argument) unless block
+
+          ancestors.reverse_each do |ancestor|
+            if ancestor <= Command
+              ancestor.arguments.each(&block)
             end
           end
-
-          puts if options[:title]
-          return nil
         end
 
         #
-        # Prints an exception and a shortened backtrace.
+        # Creates an OptionParser for the command.
         #
-        # @param [Exception] exception
-        #   The exception to print.
+        # @yield [opts]
+        #   The given block will be passed the new OptionParser, after
+        #   all options have been defined, but before the Arguments have
+        #   been listed.
         #
-        # @since 1.0.0
+        # @yieldparam [OptionParser] opts
+        #   The newly created OptionParser.
+        #
+        # @return [OptionParser]
+        #   The new configured OptionParser.
+        #
+        # @since 1.4.0
         #
         # @api semipublic
         #
-        def print_exception(exception)
-          print_error exception.message
+        def option_parser
+          OptionParser.new do |opts|
+            opts.banner = "Usage: ronin #{self.class.command_name} #{self.class.usage}"
+
+            # append the arguments to the banner
+            self.class.each_argument do |name|
+              opts.banner << " #{name.to_s.upcase}"
+            end
+
+            opts.separator ''
+            opts.separator 'Options:'
+
+            self.class.each_option do |name,options|
+              Parameters::Options.define(opts,get_param(name),options)
+            end
+
+            yield opts if block_given?
+
+            opts.separator ''
+            opts.separator 'Arguments:'
+
+            self.class.each_argument do |name|
+              param = get_param(name)
 
-          (0..5).each do |i|
-            print_error '  ' + exception.backtrace[i]
+              opts.separator "\t#{name.to_s.upcase}\t#{param.description}"
+            end
+
+            if self.class.summary
+              opts.separator ''
+              opts.separator self.class.summary
+            end
           end
         end