textgoeshere-daemon-kit 0.1.8rc3

data/lib/daemon_kit/vendor/thor-0.13.6/lib/thor/actions/inject_into_file.rb

@@ -0,0 +1,104 @@
+require 'thor/actions/empty_directory'
+
+class Thor
+  module Actions
+
+    # Injects the given content into a file. Different from gsub_file, this
+    # method is reversible.
+    #
+    # ==== Parameters
+    # destination<String>:: Relative path to the destination root
+    # data<String>:: Data to add to the file. Can be given as a block.
+    # config<Hash>:: give :verbose => false to not log the status and the flag
+    #                for injection (:after or :before) or :force => true for 
+    #                insert two or more times the same content.
+    # 
+    # ==== Examples
+    #
+    #   inject_into_file "config/environment.rb", "config.gem :thor", :after => "Rails::Initializer.run do |config|\n"
+    #
+    #   inject_into_file "config/environment.rb", :after => "Rails::Initializer.run do |config|\n" do
+    #     gems = ask "Which gems would you like to add?"
+    #     gems.split(" ").map{ |gem| "  config.gem :#{gem}" }.join("\n")
+    #   end
+    #
+    def inject_into_file(destination, *args, &block)
+      if block_given?
+        data, config = block, args.shift
+      else
+        data, config = args.shift, args.shift
+      end
+      action InjectIntoFile.new(self, destination, data, config)
+    end
+
+    class InjectIntoFile < EmptyDirectory #:nodoc:
+      attr_reader :replacement, :flag, :behavior
+
+      def initialize(base, destination, data, config)
+        super(base, destination, { :verbose => true }.merge(config))
+
+        @behavior, @flag = if @config.key?(:after)
+          [:after, @config.delete(:after)]
+        else
+          [:before, @config.delete(:before)]
+        end
+
+        @replacement = data.is_a?(Proc) ? data.call : data
+        @flag = Regexp.escape(@flag) unless @flag.is_a?(Regexp)
+      end
+
+      def invoke!
+        say_status :invoke
+
+        content = if @behavior == :after
+          '\0' + replacement
+        else
+          replacement + '\0'
+        end
+
+        replace!(/#{flag}/, content, config[:force])
+      end
+
+      def revoke!
+        say_status :revoke
+
+        regexp = if @behavior == :after
+          content = '\1\2'
+          /(#{flag})(.*)(#{Regexp.escape(replacement)})/m
+        else
+          content = '\2\3'
+          /(#{Regexp.escape(replacement)})(.*)(#{flag})/m
+        end
+
+        replace!(regexp, content, true)
+      end
+
+      protected
+
+        def say_status(behavior)
+          status = if flag == /\A/
+            behavior == :invoke ? :prepend : :unprepend
+          elsif flag == /\z/
+            behavior == :invoke ? :append : :unappend
+          else
+            behavior == :invoke ? :inject : :deinject
+          end
+
+          super(status, config[:verbose])
+        end
+
+        # Adds the content to the file.
+        #
+        def replace!(regexp, string, force)
+          unless base.options[:pretend]
+            content = File.binread(destination)
+            if force || !content.include?(replacement)
+              content.gsub!(regexp, string)
+              File.open(destination, 'wb') { |file| file.write(content) }
+            end
+          end
+        end
+
+    end
+  end
+end

data/lib/daemon_kit/vendor/thor-0.13.6/lib/thor/actions.rb

@@ -0,0 +1,296 @@
+require 'fileutils'
+require 'uri'
+require 'thor/core_ext/file_binary_read'
+
+Dir[File.join(File.dirname(__FILE__), "actions", "*.rb")].each do |action|
+  require action
+end
+
+class Thor
+  module Actions
+    attr_accessor :behavior
+
+    def self.included(base) #:nodoc:
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      # Hold source paths for one Thor instance. source_paths_for_search is the
+      # method responsible to gather source_paths from this current class,
+      # inherited paths and the source root.
+      #
+      def source_paths
+        @_source_paths ||= []
+      end
+
+      # Stores and return the source root for this class
+      def source_root(path=nil)
+        @_source_root = path if path
+        @_source_root
+      end
+
+      # Returns the source paths in the following order:
+      #
+      #   1) This class source paths
+      #   2) Source root
+      #   3) Parents source paths
+      #
+      def source_paths_for_search
+        paths = []
+        paths += self.source_paths
+        paths << self.source_root if self.source_root
+        paths += from_superclass(:source_paths, [])
+        paths
+      end
+
+      # Add runtime options that help actions execution.
+      #
+      def add_runtime_options!
+        class_option :force, :type => :boolean, :aliases => "-f", :group => :runtime,
+                             :desc => "Overwrite files that already exist"
+
+        class_option :pretend, :type => :boolean, :aliases => "-p", :group => :runtime,
+                               :desc => "Run but do not make any changes"
+
+        class_option :quiet, :type => :boolean, :aliases => "-q", :group => :runtime,
+                             :desc => "Supress status output"
+
+        class_option :skip, :type => :boolean, :aliases => "-s", :group => :runtime,
+                            :desc => "Skip files that already exist"
+      end
+    end
+
+    # Extends initializer to add more configuration options.
+    #
+    # ==== Configuration
+    # behavior<Symbol>:: The actions default behavior. Can be :invoke or :revoke.
+    #                    It also accepts :force, :skip and :pretend to set the behavior
+    #                    and the respective option.
+    #
+    # destination_root<String>:: The root directory needed for some actions.
+    #
+    def initialize(args=[], options={}, config={})
+      self.behavior = case config[:behavior].to_s
+        when "force", "skip"
+          _cleanup_options_and_set(options, config[:behavior])
+          :invoke
+        when "revoke"
+          :revoke
+        else
+          :invoke
+      end
+
+      super
+      self.destination_root = config[:destination_root]
+    end
+
+    # Wraps an action object and call it accordingly to the thor class behavior.
+    #
+    def action(instance) #:nodoc:
+      if behavior == :revoke
+        instance.revoke!
+      else
+        instance.invoke!
+      end
+    end
+
+    # Returns the root for this thor class (also aliased as destination root).
+    #
+    def destination_root
+      @destination_stack.last
+    end
+
+    # Sets the root for this thor class. Relatives path are added to the
+    # directory where the script was invoked and expanded.
+    #
+    def destination_root=(root)
+      @destination_stack ||= []
+      @destination_stack[0] = File.expand_path(root || '')
+    end
+
+    # Returns the given path relative to the absolute root (ie, root where
+    # the script started).
+    #
+    def relative_to_original_destination_root(path, remove_dot=true)
+      path = path.gsub(@destination_stack[0], '.')
+      remove_dot ? (path[2..-1] || '') : path
+    end
+
+    # Holds source paths in instance so they can be manipulated.
+    #
+    def source_paths
+      @source_paths ||= self.class.source_paths_for_search
+    end
+
+    # Receives a file or directory and search for it in the source paths.
+    #
+    def find_in_source_paths(file)
+      relative_root = relative_to_original_destination_root(destination_root, false)
+
+      source_paths.each do |source|
+        source_file = File.expand_path(file, File.join(source, relative_root))
+        return source_file if File.exists?(source_file)
+      end
+
+      message = "Could not find #{file.inspect} in any of your source paths. "
+
+      unless self.class.source_root
+        message << "Please invoke #{self.class.name}.source_root(PATH) with the PATH containing your templates. "
+      end
+
+      if source_paths.empty?
+        message << "Currently you have no source paths."
+      else
+        message << "Your current source paths are: \n#{source_paths.join("\n")}"
+      end
+
+      raise Error, message
+    end
+
+    # Do something in the root or on a provided subfolder. If a relative path
+    # is given it's referenced from the current root. The full path is yielded
+    # to the block you provide. The path is set back to the previous path when
+    # the method exits.
+    #
+    # ==== Parameters
+    # dir<String>:: the directory to move to.
+    # config<Hash>:: give :verbose => true to log and use padding.
+    #
+    def inside(dir='', config={}, &block)
+      verbose = config.fetch(:verbose, false)
+
+      say_status :inside, dir, verbose
+      shell.padding += 1 if verbose
+      @destination_stack.push File.expand_path(dir, destination_root)
+
+      FileUtils.mkdir_p(destination_root) unless File.exist?(destination_root)
+      FileUtils.cd(destination_root) { block.arity == 1 ? yield(destination_root) : yield }
+
+      @destination_stack.pop
+      shell.padding -= 1 if verbose
+    end
+
+    # Goes to the root and execute the given block.
+    #
+    def in_root
+      inside(@destination_stack.first) { yield }
+    end
+
+    # Loads an external file and execute it in the instance binding.
+    #
+    # ==== Parameters
+    # path<String>:: The path to the file to execute. Can be a web address or
+    #                a relative path from the source root.
+    #
+    # ==== Examples
+    #
+    #   apply "http://gist.github.com/103208"
+    #
+    #   apply "recipes/jquery.rb"
+    #
+    def apply(path, config={})
+      verbose = config.fetch(:verbose, true)
+      path    = find_in_source_paths(path) unless path =~ /^http\:\/\//
+
+      say_status :apply, path, verbose
+      shell.padding += 1 if verbose
+
+      if URI(path).is_a?(URI::HTTP)
+        contents = open(path, "Accept" => "application/x-thor-template") {|io| io.read }
+      else
+        contents = open(path) {|io| io.read }
+      end
+
+      instance_eval(contents, path)
+      shell.padding -= 1 if verbose
+    end
+
+    # Executes a command returning the contents of the command.
+    #
+    # ==== Parameters
+    # command<String>:: the command to be executed.
+    # config<Hash>:: give :verbose => false to not log the status. Specify :with
+    #                to append an executable to command executation.
+    #
+    # ==== Example
+    #
+    #   inside('vendor') do
+    #     run('ln -s ~/edge rails')
+    #   end
+    #
+    def run(command, config={})
+      return unless behavior == :invoke
+
+      destination = relative_to_original_destination_root(destination_root, false)
+      desc = "#{command} from #{destination.inspect}"
+
+      if config[:with]
+        desc = "#{File.basename(config[:with].to_s)} #{desc}"
+        command = "#{config[:with]} #{command}"
+      end
+
+      say_status :run, desc, config.fetch(:verbose, true)
+      `#{command}` unless options[:pretend]
+    end
+
+    # Executes a ruby script (taking into account WIN32 platform quirks).
+    #
+    # ==== Parameters
+    # command<String>:: the command to be executed.
+    # config<Hash>:: give :verbose => false to not log the status.
+    #
+    def run_ruby_script(command, config={})
+      return unless behavior == :invoke
+      run command, config.merge(:with => Thor::Util.ruby_command)
+    end
+
+    # Run a thor command. A hash of options can be given and it's converted to
+    # switches.
+    #
+    # ==== Parameters
+    # task<String>:: the task to be invoked
+    # args<Array>:: arguments to the task
+    # config<Hash>:: give :verbose => false to not log the status. Other options
+    #                are given as parameter to Thor.
+    #
+    # ==== Examples
+    #
+    #   thor :install, "http://gist.github.com/103208"
+    #   #=> thor install http://gist.github.com/103208
+    #
+    #   thor :list, :all => true, :substring => 'rails'
+    #   #=> thor list --all --substring=rails
+    #
+    def thor(task, *args)
+      config  = args.last.is_a?(Hash) ? args.pop : {}
+      verbose = config.key?(:verbose) ? config.delete(:verbose) : true
+      pretend = config.key?(:pretend) ? config.delete(:pretend) : false
+
+      args.unshift task
+      args.push Thor::Options.to_switches(config)
+      command = args.join(' ').strip
+
+      run command, :with => :thor, :verbose => verbose, :pretend => pretend
+    end
+
+    protected
+
+      # Allow current root to be shared between invocations.
+      #
+      def _shared_configuration #:nodoc:
+        super.merge!(:destination_root => self.destination_root)
+      end
+
+      def _cleanup_options_and_set(options, key) #:nodoc:
+        case options
+          when Array
+            %w(--force -f --skip -s).each { |i| options.delete(i) }
+            options << "--#{key}"
+          when Hash
+            [:force, :skip, "force", "skip"].each { |i| options.delete(i) }
+            options.merge!(key => true)
+        end
+      end
+
+  end
+end

data/lib/daemon_kit/vendor/thor-0.13.6/lib/thor/base.rb

@@ -0,0 +1,540 @@
+require 'thor/core_ext/hash_with_indifferent_access'
+require 'thor/core_ext/ordered_hash'
+require 'thor/error'
+require 'thor/shell'
+require 'thor/invocation'
+require 'thor/parser'
+require 'thor/task'
+require 'thor/util'
+
+class Thor
+  autoload :Actions,    'thor/actions'
+  autoload :RakeCompat, 'thor/rake_compat'
+
+  # Shortcuts for help.
+  HELP_MAPPINGS       = %w(-h -? --help -D)
+
+  # Thor methods that should not be overwritten by the user.
+  THOR_RESERVED_WORDS = %w(invoke shell options behavior root destination_root relative_root
+                           action add_file create_file in_root inside run run_ruby_script)
+
+  module Base
+    attr_accessor :options
+
+    # It receives arguments in an Array and two hashes, one for options and
+    # other for configuration.
+    #
+    # Notice that it does not check if all required arguments were supplied.
+    # It should be done by the parser.
+    #
+    # ==== Parameters
+    # args<Array[Object]>:: An array of objects. The objects are applied to their
+    #                       respective accessors declared with <tt>argument</tt>.
+    #
+    # options<Hash>:: An options hash that will be available as self.options.
+    #                 The hash given is converted to a hash with indifferent
+    #                 access, magic predicates (options.skip?) and then frozen.
+    #
+    # config<Hash>:: Configuration for this Thor class.
+    #
+    def initialize(args=[], options={}, config={})
+      args = Thor::Arguments.parse(self.class.arguments, args)
+      args.each { |key, value| send("#{key}=", value) }
+
+      parse_options = self.class.class_options
+
+      if options.is_a?(Array)
+        task_options  = config.delete(:task_options) # hook for start
+        parse_options = parse_options.merge(task_options) if task_options
+        array_options, hash_options = options, {}
+      else
+        array_options, hash_options = [], options
+      end
+
+      opts = Thor::Options.new(parse_options, hash_options)
+      self.options = opts.parse(array_options)
+      opts.check_unknown! if self.class.check_unknown_options?
+    end
+
+    class << self
+      def included(base) #:nodoc:
+        base.send :extend,  ClassMethods
+        base.send :include, Invocation
+        base.send :include, Shell
+      end
+
+      # Returns the classes that inherits from Thor or Thor::Group.
+      #
+      # ==== Returns
+      # Array[Class]
+      #
+      def subclasses
+        @subclasses ||= []
+      end
+
+      # Returns the files where the subclasses are kept.
+      #
+      # ==== Returns
+      # Hash[path<String> => Class]
+      #
+      def subclass_files
+        @subclass_files ||= Hash.new{ |h,k| h[k] = [] }
+      end
+
+      # Whenever a class inherits from Thor or Thor::Group, we should track the
+      # class and the file on Thor::Base. This is the method responsable for it.
+      #
+      def register_klass_file(klass) #:nodoc:
+        file = caller[1].match(/(.*):\d+/)[1]
+        Thor::Base.subclasses << klass unless Thor::Base.subclasses.include?(klass)
+
+        file_subclasses = Thor::Base.subclass_files[File.expand_path(file)]
+        file_subclasses << klass unless file_subclasses.include?(klass)
+      end
+    end
+
+    module ClassMethods
+      attr_accessor :debugging
+
+      def attr_reader(*) #:nodoc:
+        no_tasks { super }
+      end
+
+      def attr_writer(*) #:nodoc:
+        no_tasks { super }
+      end
+
+      def attr_accessor(*) #:nodoc:
+        no_tasks { super }
+      end
+
+      # If you want to raise an error for unknown options, call check_unknown_options!
+      # This is disabled by default to allow dynamic invocations.
+      def check_unknown_options!
+        @check_unknown_options = true
+      end
+
+      def check_unknown_options? #:nodoc:
+        @check_unknown_options || false
+      end
+
+      # Adds an argument to the class and creates an attr_accessor for it.
+      #
+      # Arguments are different from options in several aspects. The first one
+      # is how they are parsed from the command line, arguments are retrieved
+      # from position:
+      #
+      #   thor task NAME
+      #
+      # Instead of:
+      #
+      #   thor task --name=NAME
+      #
+      # Besides, arguments are used inside your code as an accessor (self.argument),
+      # while options are all kept in a hash (self.options).
+      #
+      # Finally, arguments cannot have type :default or :boolean but can be
+      # optional (supplying :optional => :true or :required => false), although
+      # you cannot have a required argument after a non-required argument. If you
+      # try it, an error is raised.
+      #
+      # ==== Parameters
+      # name<Symbol>:: The name of the argument.
+      # options<Hash>:: Described below.
+      #
+      # ==== Options
+      # :desc     - Description for the argument.
+      # :required - If the argument is required or not.
+      # :optional - If the argument is optional or not.
+      # :type     - The type of the argument, can be :string, :hash, :array, :numeric.
+      # :default  - Default value for this argument. It cannot be required and have default values.
+      # :banner   - String to show on usage notes.
+      #
+      # ==== Errors
+      # ArgumentError:: Raised if you supply a required argument after a non required one.
+      #
+      def argument(name, options={})
+        is_thor_reserved_word?(name, :argument)
+        no_tasks { attr_accessor name }
+
+        required = if options.key?(:optional)
+          !options[:optional]
+        elsif options.key?(:required)
+          options[:required]
+        else
+          options[:default].nil?
+        end
+
+        remove_argument name
+
+        arguments.each do |argument|
+          next if argument.required?
+          raise ArgumentError, "You cannot have #{name.to_s.inspect} as required argument after " <<
+                               "the non-required argument #{argument.human_name.inspect}."
+        end if required
+
+        arguments << Thor::Argument.new(name, options[:desc], required, options[:type],
+                                              options[:default], options[:banner])
+      end
+
+      # Returns this class arguments, looking up in the ancestors chain.
+      #
+      # ==== Returns
+      # Array[Thor::Argument]
+      #
+      def arguments
+        @arguments ||= from_superclass(:arguments, [])
+      end
+
+      # Adds a bunch of options to the set of class options.
+      #
+      #   class_options :foo => false, :bar => :required, :baz => :string
+      #
+      # If you prefer more detailed declaration, check class_option.
+      #
+      # ==== Parameters
+      # Hash[Symbol => Object]
+      #
+      def class_options(options=nil)
+        @class_options ||= from_superclass(:class_options, {})
+        build_options(options, @class_options) if options
+        @class_options
+      end
+
+      # Adds an option to the set of class options
+      #
+      # ==== Parameters
+      # name<Symbol>:: The name of the argument.
+      # options<Hash>:: Described below.
+      #
+      # ==== Options
+      # :desc     - Description for the argument.
+      # :required - If the argument is required or not.
+      # :default  - Default value for this argument.
+      # :group    - The group for this options. Use by class options to output options in different levels.
+      # :aliases  - Aliases for this option.
+      # :type     - The type of the argument, can be :string, :hash, :array, :numeric or :boolean.
+      # :banner   - String to show on usage notes.
+      #
+      def class_option(name, options={})
+        build_option(name, options, class_options)
+      end
+
+      # Removes a previous defined argument. If :undefine is given, undefine
+      # accessors as well.
+      #
+      # ==== Paremeters
+      # names<Array>:: Arguments to be removed
+      #
+      # ==== Examples
+      #
+      #   remove_argument :foo
+      #   remove_argument :foo, :bar, :baz, :undefine => true
+      #
+      def remove_argument(*names)
+        options = names.last.is_a?(Hash) ? names.pop : {}
+
+        names.each do |name|
+          arguments.delete_if { |a| a.name == name.to_s }
+          undef_method name, "#{name}=" if options[:undefine]
+        end
+      end
+
+      # Removes a previous defined class option.
+      #
+      # ==== Paremeters
+      # names<Array>:: Class options to be removed
+      #
+      # ==== Examples
+      #
+      #   remove_class_option :foo
+      #   remove_class_option :foo, :bar, :baz
+      #
+      def remove_class_option(*names)
+        names.each do |name|
+          class_options.delete(name)
+        end
+      end
+
+      # Defines the group. This is used when thor list is invoked so you can specify
+      # that only tasks from a pre-defined group will be shown. Defaults to standard.
+      #
+      # ==== Parameters
+      # name<String|Symbol>
+      #
+      def group(name=nil)
+        case name
+          when nil
+            @group ||= from_superclass(:group, 'standard')
+          else
+            @group = name.to_s
+        end
+      end
+
+      # Returns the tasks for this Thor class.
+      #
+      # ==== Returns
+      # OrderedHash:: An ordered hash with tasks names as keys and Thor::Task
+      #               objects as values.
+      #
+      def tasks
+        @tasks ||= Thor::CoreExt::OrderedHash.new
+      end
+
+      # Returns the tasks for this Thor class and all subclasses.
+      #
+      # ==== Returns
+      # OrderedHash:: An ordered hash with tasks names as keys and Thor::Task
+      #               objects as values.
+      #
+      def all_tasks
+        @all_tasks ||= from_superclass(:all_tasks, Thor::CoreExt::OrderedHash.new)
+        @all_tasks.merge(tasks)
+      end
+
+      # Removes a given task from this Thor class. This is usually done if you
+      # are inheriting from another class and don't want it to be available
+      # anymore.
+      #
+      # By default it only remove the mapping to the task. But you can supply
+      # :undefine => true to undefine the method from the class as well.
+      #
+      # ==== Parameters
+      # name<Symbol|String>:: The name of the task to be removed
+      # options<Hash>:: You can give :undefine => true if you want tasks the method
+      #                 to be undefined from the class as well.
+      #
+      def remove_task(*names)
+        options = names.last.is_a?(Hash) ? names.pop : {}
+
+        names.each do |name|
+          tasks.delete(name.to_s)
+          all_tasks.delete(name.to_s)
+          undef_method name if options[:undefine]
+        end
+      end
+
+      # All methods defined inside the given block are not added as tasks.
+      #
+      # So you can do:
+      #
+      #   class MyScript < Thor
+      #     no_tasks do
+      #       def this_is_not_a_task
+      #       end
+      #     end
+      #   end
+      #
+      # You can also add the method and remove it from the task list:
+      #
+      #   class MyScript < Thor
+      #     def this_is_not_a_task
+      #     end
+      #     remove_task :this_is_not_a_task
+      #   end
+      #
+      def no_tasks
+        @no_tasks = true
+        yield
+        @no_tasks = false
+      end
+
+      # Sets the namespace for the Thor or Thor::Group class. By default the
+      # namespace is retrieved from the class name. If your Thor class is named
+      # Scripts::MyScript, the help method, for example, will be called as:
+      #
+      #   thor scripts:my_script -h
+      #
+      # If you change the namespace:
+      #
+      #   namespace :my_scripts
+      #
+      # You change how your tasks are invoked:
+      #
+      #   thor my_scripts -h
+      #
+      # Finally, if you change your namespace to default:
+      #
+      #   namespace :default
+      #
+      # Your tasks can be invoked with a shortcut. Instead of:
+      #
+      #   thor :my_task
+      #
+      def namespace(name=nil)
+        case name
+          when nil
+            @namespace ||= Thor::Util.namespace_from_thor_class(self)
+          else
+            @namespace = name.to_s
+        end
+      end
+
+      # Default way to start generators from the command line.
+      #
+      def start(given_args=ARGV, config={})
+        self.debugging = given_args.include?("--debug")
+        config[:shell] ||= Thor::Base.shell.new
+        yield(given_args.dup)
+      rescue Thor::Error => e
+        debugging ? (raise e) : config[:shell].error(e.message)
+        exit(1) if exit_on_failure?
+      end
+
+      def handle_no_task_error(task) #:nodoc:
+        if self.banner_base == "thor"
+          raise UndefinedTaskError, "Could not find task #{task.inspect} in #{namespace.inspect} namespace."
+        else
+          raise UndefinedTaskError, "Could not find task #{task.inspect}."
+        end
+      end
+
+      protected
+
+        # Prints the class options per group. If an option does not belong to
+        # any group, it's printed as Class option.
+        #
+        def class_options_help(shell, groups={}) #:nodoc:
+          # Group options by group
+          class_options.each do |_, value|
+            groups[value.group] ||= []
+            groups[value.group] << value
+          end
+
+          # Deal with default group
+          global_options = groups.delete(nil) || []
+          print_options(shell, global_options)
+
+          # Print all others
+          groups.each do |group_name, options|
+            print_options(shell, options, group_name)
+          end
+        end
+
+        # Receives a set of options and print them.
+        def print_options(shell, options, group_name=nil)
+          return if options.empty?
+
+          list = []
+          padding = options.collect{ |o| o.aliases.size }.max.to_i * 4
+
+          options.each do |option|
+            item = [ option.usage(padding) ]
+            item.push(option.description ? "# #{option.description}" : "")
+
+            list << item
+            list << [ "", "# Default: #{option.default}" ] if option.show_default?
+          end
+
+          shell.say(group_name ? "#{group_name} options:" : "Options:")
+          shell.print_table(list, :ident => 2)
+          shell.say ""
+        end
+
+        # Raises an error if the word given is a Thor reserved word.
+        def is_thor_reserved_word?(word, type) #:nodoc:
+          return false unless THOR_RESERVED_WORDS.include?(word.to_s)
+          raise "#{word.inspect} is a Thor reserved word and cannot be defined as #{type}"
+        end
+
+        # Build an option and adds it to the given scope.
+        #
+        # ==== Parameters
+        # name<Symbol>:: The name of the argument.
+        # options<Hash>:: Described in both class_option and method_option.
+        def build_option(name, options, scope) #:nodoc:
+          scope[name] = Thor::Option.new(name, options[:desc], options[:required],
+                                               options[:type], options[:default], options[:banner],
+                                               options[:group], options[:aliases])
+        end
+
+        # Receives a hash of options, parse them and add to the scope. This is a
+        # fast way to set a bunch of options:
+        #
+        #   build_options :foo => true, :bar => :required, :baz => :string
+        #
+        # ==== Parameters
+        # Hash[Symbol => Object]
+        def build_options(options, scope) #:nodoc:
+          options.each do |key, value|
+            scope[key] = Thor::Option.parse(key, value)
+          end
+        end
+
+        # Finds a task with the given name. If the task belongs to the current
+        # class, just return it, otherwise dup it and add the fresh copy to the
+        # current task hash.
+        def find_and_refresh_task(name) #:nodoc:
+          task = if task = tasks[name.to_s]
+            task
+          elsif task = all_tasks[name.to_s]
+            tasks[name.to_s] = task.clone
+          else
+            raise ArgumentError, "You supplied :for => #{name.inspect}, but the task #{name.inspect} could not be found."
+          end
+        end
+
+        # Everytime someone inherits from a Thor class, register the klass
+        # and file into baseclass.
+        def inherited(klass)
+          Thor::Base.register_klass_file(klass)
+        end
+
+        # Fire this callback whenever a method is added. Added methods are
+        # tracked as tasks by invoking the create_task method.
+        def method_added(meth)
+          meth = meth.to_s
+
+          if meth == "initialize"
+            initialize_added
+            return
+          end
+
+          # Return if it's not a public instance method
+          return unless public_instance_methods.include?(meth) ||
+                        public_instance_methods.include?(meth.to_sym)
+
+          return if @no_tasks || !create_task(meth)
+
+          is_thor_reserved_word?(meth, :task)
+          Thor::Base.register_klass_file(self)
+        end
+
+        # Retrieves a value from superclass. If it reaches the baseclass,
+        # returns default.
+        def from_superclass(method, default=nil)
+          if self == baseclass || !superclass.respond_to?(method, true)
+            default
+          else
+            value = superclass.send(method)
+            value.dup if value
+          end
+        end
+
+        # A flag that makes the process exit with status 1 if any error happens.
+        def exit_on_failure?
+          false
+        end
+
+        # Returns the base for banner.
+        def banner_base
+          @banner_base ||= $thor_runner ? "thor" : File.basename($0.split(" ").first)
+        end
+
+        # SIGNATURE: Sets the baseclass. This is where the superclass lookup
+        # finishes.
+        def baseclass #:nodoc:
+        end
+
+        # SIGNATURE: Creates a new task if valid_task? is true. This method is
+        # called when a new method is added to the class.
+        def create_task(meth) #:nodoc:
+        end
+
+        # SIGNATURE: Defines behavior when the initialize method is added to the
+        # class.
+        def initialize_added #:nodoc:
+        end
+    end
+  end
+end