wycats-thor 0.9.8 → 0.10.26

data/lib/thor/parser/arguments.rb

@@ -0,0 +1,145 @@
+class Thor
+  class Arguments
+    NUMERIC = /(\d*\.\d+|\d+)/
+
+    # Receives an array of args and returns two arrays, one with arguments
+    # and one with switches.
+    #
+    def self.split(args)
+      arguments = []
+
+      args.each do |item|
+        break if item =~ /^-/
+        arguments << item
+      end
+
+      return arguments, args[Range.new(arguments.size, -1)]
+    end
+
+    def self.parse(base, args)
+      new(base).parse(args)
+    end
+
+    # Takes an array of Thor::Argument objects.
+    #
+    def initialize(arguments=[])
+      @assigns, @non_assigned_required = {}, []
+      @switches = arguments
+
+      arguments.each do |argument|
+        if argument.default
+          @assigns[argument.human_name] = argument.default
+        elsif argument.required?
+          @non_assigned_required << argument
+        end
+      end
+    end
+
+    def parse(args)
+      @pile = args.dup
+
+      @switches.each do |argument|
+        break unless peek
+        @non_assigned_required.delete(argument)
+        @assigns[argument.human_name] = send(:"parse_#{argument.type}", argument.human_name)
+      end
+
+      check_requirement!
+      @assigns
+    end
+
+    private
+
+      def peek
+        @pile.first
+      end
+
+      def shift
+        @pile.shift
+      end
+
+      def unshift(arg)
+        unless arg.kind_of?(Array)
+          @pile.unshift(arg)
+        else
+          @pile = arg + @pile
+        end
+      end
+
+      def current_is_value?
+        peek && peek.to_s !~ /^-/
+      end
+
+      # Runs through the argument array getting strings that contains ":" and
+      # mark it as a hash:
+      #
+      #   [ "name:string", "age:integer" ]
+      #
+      # Becomes:
+      #
+      #   { "name" => "string", "age" => "integer" }
+      #
+      def parse_hash(name)
+        return shift if peek.is_a?(Hash)
+        hash = {}
+
+        while current_is_value? && peek.include?(?:)
+          key, value = shift.split(':')
+          hash[key] = value
+        end
+        hash
+      end
+
+      # Runs through the argument array getting all strings until no string is
+      # found or a switch is found.
+      #
+      #   ["a", "b", "c"]
+      #
+      # And returns it as an array:
+      #
+      #   ["a", "b", "c"]
+      #
+      def parse_array(name)
+        return shift if peek.is_a?(Array)
+        array = []
+
+        while current_is_value?
+          array << shift
+        end
+        array
+      end
+
+      # Check if the peel is numeric ofrmat and return a Float or Integer.
+      # Otherwise raises an error.
+      #
+      def parse_numeric(name)
+        return shift if peek.is_a?(Numeric)
+
+        unless peek =~ NUMERIC && $& == peek
+          raise MalformattedArgumentError, "expected numeric value for '#{name}'; got #{peek.inspect}"
+        end
+
+        $&.index('.') ? shift.to_f : shift.to_i
+      end
+
+      # Parse string, i.e., just return the current value in the pile.
+      #
+      def parse_string(name)
+        shift
+      end
+
+      # Raises an error if @non_assigned_required array is not empty.
+      #
+      def check_requirement!
+        unless @non_assigned_required.empty?
+          names = @non_assigned_required.map do |o|
+            o.respond_to?(:switch_name) ? o.switch_name : o.human_name
+          end.join("', '")
+
+          class_name = self.class.name.split('::').last.downcase
+          raise RequiredArgumentMissingError, "no value provided for required #{class_name} '#{names}'"
+        end
+      end
+
+  end
+end

data/lib/thor/parser/option.rb

@@ -0,0 +1,125 @@
+class Thor
+  class Option < Argument
+    attr_reader :aliases, :group
+
+    VALID_TYPES = [:boolean, :numeric, :hash, :array, :string]
+
+    def initialize(name, description=nil, required=nil, type=nil, default=nil, banner=nil, group=nil, aliases=nil)
+      super(name, description, required, type, default, banner)
+      @aliases = [*aliases].compact
+      @group   = group.to_s.capitalize if group
+    end
+
+    # This parse quick options given as method_options. It makes several
+    # assumptions, but you can be more specific using the option method.
+    #
+    #   parse :foo => "bar"
+    #   #=> Option foo with default value bar
+    #
+    #   parse [:foo, :baz] => "bar"
+    #   #=> Option foo with default value bar and alias :baz
+    #
+    #   parse :foo => :required
+    #   #=> Required option foo without default value
+    #
+    #   parse :foo => 2
+    #   #=> Option foo with default value 2 and type numeric
+    #
+    #   parse :foo => :numeric
+    #   #=> Option foo without default value and type numeric
+    #
+    #   parse :foo => true
+    #   #=> Option foo with default value true and type boolean
+    #
+    # The valid types are :boolean, :numeric, :hash, :array and :string. If none
+    # is given a default type is assumed. This default type accepts arguments as
+    # string (--foo=value) or booleans (just --foo).
+    #
+    # By default all options are optional, unless :required is given.
+    # 
+    def self.parse(key, value)
+      if key.is_a?(Array)
+        name, *aliases = key
+      else
+        name, aliases = key, []
+      end
+
+      name    = name.to_s
+      default = value
+
+      type = case value
+        when Symbol
+          default  = nil
+
+          if VALID_TYPES.include?(value)
+            value
+          elsif required = (value == :required)
+            :string
+          elsif value == :optional
+            # TODO Remove this warning in the future.
+            warn "Optional type is deprecated. Choose :boolean or :string instead. Assumed to be :boolean."
+            :boolean
+          end
+        when TrueClass, FalseClass
+          :boolean
+        when Numeric
+          :numeric
+        when Hash, Array, String
+          value.class.name.downcase.to_sym
+      end
+
+      self.new(name.to_s, nil, required, type, default, nil, nil, aliases)
+    end
+
+    def switch_name
+      @switch_name ||= dasherized? ? name : dasherize(name)
+    end
+
+    def human_name
+      @human_name ||= dasherized? ? undasherize(name) : name
+    end
+
+    def usage(padding=0)
+      sample = if banner && !banner.to_s.empty?
+        "#{switch_name}=#{banner}"
+      else
+        switch_name
+      end
+
+      sample = "[#{sample}]" unless required?
+
+      if aliases.empty?
+        (" " * padding) << sample
+      else
+        "#{aliases.join(', ')}, #{sample}"
+      end
+    end
+
+    def input_required?
+      type != :boolean
+    end
+
+    protected
+
+      def validate!
+        raise ArgumentError, "An option cannot be boolean and required." if type == :boolean && required?
+      end
+
+      def valid_type?(type)
+        VALID_TYPES.include?(type.to_sym)
+      end
+
+      def dasherized?
+        name.index('-') == 0
+      end
+
+      def undasherize(str)
+        str.sub(/^-{1,2}/, '')
+      end
+
+      def dasherize(str)
+        (str.length > 1 ? "--" : "-") + str.gsub('_', '-')
+      end
+
+  end
+end

data/lib/thor/parser/options.rb

@@ -0,0 +1,135 @@
+class Thor
+  # This is a modified version of Daniel Berger's Getopt::Long class, licensed
+  # under Ruby's license.
+  #
+  class Options < Arguments
+    LONG_RE     = /^(--\w+[-\w+]*)$/
+    SHORT_RE    = /^(-[a-z])$/i
+    EQ_RE       = /^(--\w+[-\w+]*|-[a-z])=(.*)$/i
+    SHORT_SQ_RE = /^-([a-z]{2,})$/i # Allow either -x -v or -xv style for single char args
+    SHORT_NUM   = /^(-[a-z])#{NUMERIC}$/i
+
+    # Receives a hash and makes it switches.
+    #
+    def self.to_switches(options)
+      options.map do |key, value|
+        case value
+          when true
+            "--#{key}"
+          when Array
+            "--#{key} #{value.map{ |v| v.inspect }.join(' ')}"
+          when Hash
+            "--#{key} #{value.map{ |k,v| "#{k}:#{v}" }.join(' ')}"
+          when nil, false
+            ""
+          else
+            "--#{key} #{value.inspect}"
+        end
+      end.join(" ")
+    end
+
+    # Takes a hash of Thor::Option objects.
+    #
+    def initialize(options={})
+      options = options.values
+      super(options)
+      @shorts, @switches = {}, {}
+
+      options.each do |option|
+        @switches[option.switch_name] = option
+
+        option.aliases.each do |short|
+          @shorts[short.to_s] ||= option.switch_name
+        end
+      end
+    end
+
+    def parse(args)
+      @pile = args.dup
+
+      while peek
+        if current_is_switch?
+          case shift
+            when SHORT_SQ_RE
+              unshift($1.split('').map { |f| "-#{f}" })
+              next
+            when EQ_RE, SHORT_NUM
+              unshift($2)
+              switch = $1
+            when LONG_RE, SHORT_RE
+              switch = $1
+          end
+
+          switch = normalize_switch(switch)
+          next unless option = switch_option(switch)
+
+          @assigns[option.human_name] = parse_peek(switch, option)
+        else
+          shift
+        end
+      end
+
+      check_requirement!
+      @assigns
+    end
+
+    protected
+
+      # Returns true if the current value in peek is a registered switch.
+      #
+      def current_is_switch?
+        case peek
+          when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM
+            switch?($1)
+          when SHORT_SQ_RE
+            $1.split('').any? { |f| switch?("-#{f}") }
+        end
+      end
+
+      def switch?(arg)
+        switch_option(arg) || @shorts.key?(arg)
+      end
+
+      def switch_option(arg)
+        if match = no_or_skip?(arg)
+          @switches[arg] || @switches["--#{match}"]
+        else
+          @switches[arg]
+        end
+      end
+
+      def no_or_skip?(arg)
+        arg =~ /^--(no|skip)-([-\w]+)$/
+        $2
+      end
+
+      # Check if the given argument is actually a shortcut.
+      #
+      def normalize_switch(arg)
+        @shorts.key?(arg) ? @shorts[arg] : arg
+      end
+
+      # Parse boolean values which can be given as --foo=true, --foo or --no-foo.
+      #
+      def parse_boolean(switch)
+        if current_is_value?
+          ["true", "TRUE", "t", "T", true].include?(shift)
+        else
+          @switches.key?(switch) || !no_or_skip?(switch)
+        end
+      end
+
+      # Parse the value at the peek analyzing if it requires an input or not.
+      #
+      def parse_peek(switch, option)
+        if option.input_required?
+          return nil if no_or_skip?(switch)
+          raise MalformattedArgumentError, "no value provided for option '#{switch}'" unless current_is_value?
+        end
+
+        @non_assigned_required.delete(option)
+        send(:"parse_#{option.type}", switch)
+      end
+
+  end
+end

data/lib/thor/parser.rb

@@ -0,0 +1,4 @@
+require 'thor/parser/argument'
+require 'thor/parser/arguments'
+require 'thor/parser/option'
+require 'thor/parser/options'

data/lib/thor/runner.rb

@@ -1,286 +1,295 @@
-require 'thor'
-require "thor/util"
-require "open-uri"
-require "fileutils"
-require "yaml"
-require "digest/md5"
-require "readline"
+require 'fileutils'
+require 'open-uri'
+require 'yaml'
+require 'digest/md5'
+require 'pathname'
 
 class Thor::Runner < Thor
-  
-  def self.globs_for(path)
-    ["#{path}/Thorfile", "#{path}/*.thor", "#{path}/tasks/*.thor", "#{path}/lib/tasks/*.thor"]
+  map "-T" => :list, "-i" => :install, "-u" => :update
+
+  # Override Thor#help so it can give information about any class and any method.
+  #
+  def help(meth=nil)
+    if meth && !self.respond_to?(meth)
+      initialize_thorfiles(meth)
+      klass, task = Thor::Util.namespace_to_thor_class(meth)
+      klass.start(["-h", task].compact, :shell => self.shell) # send mapping -h because it works with Thor::Group too
+    else
+      super
+    end
   end
 
-  map "-T" => :list, "-i" => :install, "-u" => :update
-  
-  desc "install NAME", "install a Thor file into your system tasks, optionally named for future updates"
-  method_options :as => :optional, :relative => :boolean
+  # If a task is not found on Thor::Runner, method missing is invoked and
+  # Thor::Runner is then responsable for finding the task in all classes.
+  #
+  def method_missing(meth, *args)
+    meth = meth.to_s
+    initialize_thorfiles(meth)
+    klass, task = Thor::Util.namespace_to_thor_class(meth)
+    args.unshift(task) if task
+    klass.start(args, :shell => shell)
+  end
+
+  desc "install NAME", "Install a Thor file into your system tasks, optionally named for future updates"
+  method_options :as => :string, :relative => :boolean
   def install(name)
     initialize_thorfiles
+
+    # If a directory name is provided as the argument, look for a 'main.thor' 
+    # task in said directory.
     begin
-      contents = open(name).read
+      if File.directory?(File.expand_path(name))
+        base, package = File.join(name, "main.thor"), :directory
+        contents      = open(base).read
+      else
+        base, package = name, :file
+        contents      = open(name).read
+      end
     rescue OpenURI::HTTPError
-      raise Error, "Error opening URI `#{name}'"
+      raise Error, "Error opening URI '#{name}'"
     rescue Errno::ENOENT
-      raise Error, "Error opening file `#{name}'"
+      raise Error, "Error opening file '#{name}'"
     end
-    
-    is_uri = File.exist?(name) ? false : true
-    
-    puts "Your Thorfile contains: "
-    puts contents
-    print "Do you wish to continue [y/N]? "
-    response = Readline.readline
-    
-    return false unless response =~ /^\s*y/i
-    
-    constants = Thor::Util.constants_in_contents(contents)
-    
-    # name = name =~ /\.thor$/ || is_uri ? name : "#{name}.thor"
-    
+
+    say "Your Thorfile contains:"
+    say contents
+
+    return false if no?("Do you wish to continue [y/N]?")
+
     as = options["as"] || begin
       first_line = contents.split("\n")[0]
       (match = first_line.match(/\s*#\s*module:\s*([^\n]*)/)) ? match[1].strip : nil
     end
-        
-    if !as
-      print "Please specify a name for #{name} in the system repository [#{name}]: "
-      as = Readline.readline
-      as = name if as.empty?
+
+    unless as
+      basename = File.basename(name)
+      as = ask("Please specify a name for #{name} in the system repository [#{basename}]:")
+      as = basename if as.empty?
+    end
+
+    location = if options[:relative] || name =~ /^http:\/\//
+      name
+    else
+      File.expand_path(name)
     end
-    
-    FileUtils.mkdir_p thor_root
-    
-    yaml_file = File.join(thor_root, "thor.yml")
-    FileUtils.touch(yaml_file)
-    yaml = thor_yaml
-    
-    location = (options[:relative] || is_uri) ? name : File.expand_path(name)
-    yaml[as] = {:filename => Digest::MD5.hexdigest(name + as), :location => location, :constants => constants}
-    
-    save_yaml(yaml)
-    
-    puts "Storing thor file in your system repository"
-    
-    File.open(File.join(thor_root, yaml[as][:filename]), "w") do |file|
-      file.puts contents
+
+    thor_yaml[as] = {
+      :filename   => Digest::MD5.hexdigest(name + as),
+      :location   => location,
+      :namespaces => Thor::Util.namespaces_in_contents(contents, base)
+    }
+
+    save_yaml(thor_yaml)
+    say "Storing thor file in your system repository"
+    destination = File.join(thor_root, thor_yaml[as][:filename])
+
+    if package == :file
+      File.open(destination, "w") { |f| f.puts contents }
+    else
+      FileUtils.cp_r(name, destination)
     end
-    
-    yaml[as][:filename] # Indicate sucess
+
+    thor_yaml[as][:filename] # Indicate success
   end
-  
-  desc "uninstall NAME", "uninstall a named Thor module"
+
+  desc "uninstall NAME", "Uninstall a named Thor module"
   def uninstall(name)
-    yaml = thor_yaml
-    raise Error, "Can't find module `#{name}'" unless yaml[name]
-    
-    puts "Uninstalling #{name}."
-    
-    file = File.join(thor_root, "#{yaml[name][:filename]}")
-    File.delete(file)
-    yaml.delete(name)
-    save_yaml(yaml)
-    
+    raise Error, "Can't find module '#{name}'" unless thor_yaml[name]
+    say "Uninstalling #{name}."
+    FileUtils.rm_rf(File.join(thor_root, "#{thor_yaml[name][:filename]}"))
+
+    thor_yaml.delete(name)
+    save_yaml(thor_yaml)
+
     puts "Done."
   end
-  
-  desc "update NAME", "update a Thor file from its original location"
+
+  desc "update NAME", "Update a Thor file from its original location"
   def update(name)
-    yaml = thor_yaml
-    raise Error, "Can't find module `#{name}'" if !yaml[name] || !yaml[name][:location]
+    raise Error, "Can't find module '#{name}'" if !thor_yaml[name] || !thor_yaml[name][:location]
 
-    puts "Updating `#{name}' from #{yaml[name][:location]}"
-    old_filename = yaml[name][:filename]
+    say "Updating '#{name}' from #{thor_yaml[name][:location]}"
+
+    old_filename = thor_yaml[name][:filename]
     self.options = self.options.merge("as" => name)
-    filename = install(yaml[name][:location])
+    filename     = install(thor_yaml[name][:location])
+
     unless filename == old_filename
       File.delete(File.join(thor_root, old_filename))
     end
   end
-  
-  desc "installed", "list the installed Thor modules and tasks (--internal means list the built-in tasks as well)"
+
+  desc "installed", "List the installed Thor modules and tasks"
   method_options :internal => :boolean
   def installed
-    thor_root_glob.each do |f|
-      next if f =~ /thor\.yml$/
-      load_thorfile f unless Thor.subclass_files.keys.include?(File.expand_path(f))
-    end
+    initialize_thorfiles(nil, true)
+
+    klasses = Thor::Base.subclasses
+    klasses -= [Thor, Thor::Runner] unless options["internal"]
 
-    klasses = Thor.subclasses
-    klasses -= [Thor, Thor::Runner] unless options['internal']
     display_klasses(true, klasses)
   end
-  
-  desc "list [SEARCH]", "list the available thor tasks (--substring means SEARCH can be anywhere in the module)"
-  method_options :substring => :boolean,
-                 :group => :optional,
-                 :all => :boolean
-  def list(search = "")
+
+  desc "list [SEARCH]",
+       "List the available thor tasks (--substring means SEARCH anywhere in the namespace)"
+  method_options :substring => :boolean, :group => :string, :all => :boolean
+  def list(search="")
     initialize_thorfiles
+
     search = ".*#{search}" if options["substring"]
     search = /^#{search}.*/i
-    group  = options[:group] || 'standard'
-    
-    classes = Thor.subclasses.select do |k| 
-      (options[:all] || k.group_name == group) && 
-      Thor::Util.constant_to_thor_path(k.name) =~ search
+    group  = options[:group] || "standard"
+
+    klasses = Thor::Base.subclasses.select do |k|
+      (options[:all] || k.group == group) && k.namespace =~ search
     end
-    display_klasses(false, classes)
-  end
 
-  # Override Thor#help so we can give info about not-yet-loaded tasks
-  def help(task = nil)
-    initialize_thorfiles(task) if task && task.include?(?:)
-    super
+    display_klasses(false, klasses)
   end
-    
-  def method_missing(meth, *args)
-    meth = meth.to_s
-    super(meth.to_sym, *args) unless meth.include? ?:
 
-    initialize_thorfiles(meth)
-    task = Thor[meth]
-    task.parse task.klass.new, ARGV[1..-1]
-  end
+  private
 
-  def self.thor_root
-    File.join(ENV["HOME"] || ENV["APPDATA"], ".thor")
-  end
+    def thor_root
+      Thor::Util.thor_root
+    end
 
-  def self.thor_root_glob
-    # On Windows thor_root will be something like this:
-    #
-    #   C:\Documents and Settings\james\.thor
+    def thor_yaml
+      @thor_yaml ||= begin
+        yaml_file = File.join(thor_root, "thor.yml")
+        yaml      = YAML.load_file(yaml_file) if File.exists?(yaml_file)
+        yaml || {}
+      end
+    end
+
+    # Save the yaml file. If none exists in thor root, creates one.
     #
-    # If we don't #gsub the \ character, Dir.glob will fail.
-    Dir["#{thor_root.gsub(/\\/, '/')}/**/*"]
-  end
-  
-  private
-  def thor_root
-    self.class.thor_root
-  end
+    def save_yaml(yaml)
+      yaml_file = File.join(thor_root, "thor.yml")
 
-  def thor_root_glob
-    self.class.thor_root_glob
-  end
-  
-  def thor_yaml
-    yaml_file = File.join(thor_root, "thor.yml")
-    yaml = YAML.load_file(yaml_file) if File.exists?(yaml_file)
-    yaml || {}
-  end
-  
-  def save_yaml(yaml)
-    yaml_file = File.join(thor_root, "thor.yml")
-    File.open(yaml_file, "w") {|f| f.puts yaml.to_yaml }
-  end
-  
-  def display_klasses(with_modules = false, klasses = Thor.subclasses)
-    klasses -= [Thor, Thor::Runner] unless with_modules
-    raise Error, "No Thor tasks available" if klasses.empty?
-    
-    if with_modules && !(yaml = thor_yaml).empty?
-      max_name = yaml.max {|(xk,xv),(yk,yv)| xk.to_s.size <=> yk.to_s.size }.first.size
-      modules_label = "Modules"
-      namespaces_label = "Namespaces"
-      column_width = [max_name + 4, modules_label.size + 1].max
-      
-      print "%-#{column_width}s" % modules_label
-      puts namespaces_label
-      print "%-#{column_width}s" % ("-" * modules_label.size)
-      puts "-" * namespaces_label.size
-      
-      yaml.each do |name, info|
-        print "%-#{column_width}s" % name
-        puts info[:constants].map {|c| Thor::Util.constant_to_thor_path(c)}.join(", ")
+      unless File.exists?(yaml_file)
+        FileUtils.mkdir_p(thor_root)
+        yaml_file = File.join(thor_root, "thor.yml")
+        FileUtils.touch(yaml_file)
       end
-    
-      puts
-    end
-    
-    # Calculate the largest base class name
-    max_base = klasses.max do |x,y| 
-      Thor::Util.constant_to_thor_path(x.name).size <=> Thor::Util.constant_to_thor_path(y.name).size
-    end.name.size
-    
-    # Calculate the size of the largest option description
-    max_left_item = klasses.max do |x,y| 
-      (x.maxima.usage + x.maxima.opt).to_i <=> (y.maxima.usage + y.maxima.opt).to_i
-    end
-    
-    max_left = max_left_item.maxima.usage + max_left_item.maxima.opt
-    
-    unless klasses.empty?
-      puts # add some spacing
-      klasses.each { |k| display_tasks(k, max_base, max_left); }
-    else
-      puts "\033[1;34mNo Thor tasks available\033[0m"
+
+      File.open(yaml_file, "w") { |f| f.puts yaml.to_yaml }
     end
-  end  
-  
-  def display_tasks(klass, max_base, max_left)
-    if klass.tasks.values.length > 1
-      
-      base = Thor::Util.constant_to_thor_path(klass.name)
-      
-      if base.to_a.empty?
-        base = 'default' 
-        puts "\033[1;35m#{base}\033[0m"
-      else
-        puts "\033[1;34m#{base}\033[0m"
+
+    # Load the thorfiles. If relevant_to is supplied, looks for specific files
+    # in the thor_root instead of loading them all.
+    #
+    # By default, it also traverses the current path until find Thor files, as
+    # described in thorfiles. This look up can be skipped by suppliying
+    # skip_lookup true.
+    #
+    def initialize_thorfiles(relevant_to=nil, skip_lookup=false)
+      thorfiles(relevant_to, skip_lookup).each do |f|
+        Thor::Util.load_thorfile(f) unless Thor::Base.subclass_files.keys.include?(File.expand_path(f))
       end
-      puts "-" * base.length
-      
-      klass.tasks.each true do |name, task|
-        format_string = "%-#{max_left + max_base + 5}s"
-        print format_string % task.formatted_usage(true)
-        puts task.description
+    end
+
+    # Finds Thorfiles by traversing from your current directory down to the root
+    # directory of your system. If at any time we find a Thor file, we stop.
+    #
+    # We also ensure that system-wide Thorfiles are loaded first, so local
+    # Thorfiles can override them.
+    #
+    # ==== Example
+    #
+    # If we start at /Users/wycats/dev/thor ...
+    #
+    # 1. /Users/wycats/dev/thor
+    # 2. /Users/wycats/dev
+    # 3. /Users/wycats <-- we find a Thorfile here, so we stop
+    #
+    # Suppose we start at c:\Documents and Settings\james\dev\thor ...
+    #
+    # 1. c:\Documents and Settings\james\dev\thor
+    # 2. c:\Documents and Settings\james\dev
+    # 3. c:\Documents and Settings\james
+    # 4. c:\Documents and Settings
+    # 5. c:\ <-- no Thorfiles found!
+    #
+    def thorfiles(relevant_to=nil, skip_lookup=false)
+      # Deal with deprecated thor when :namespaces: is available as constants
+      save_yaml(thor_yaml) if Thor::Util.convert_constants_to_namespaces(thor_yaml)
+
+      thorfiles = []
+
+      unless skip_lookup
+        Pathname.pwd.ascend do |path|
+          thorfiles = Thor::Util.globs_for(path).map { |g| Dir[g] }.flatten
+          break unless thorfiles.empty?
+        end
       end
-      
-      unless klass.opts.empty?
-        puts "\nglobal options: #{Options.new(klass.opts)}"
+
+      files  = (relevant_to ? thorfiles_relevant_to(relevant_to) : Thor::Util.thor_root_glob)
+      files += thorfiles
+      files -= ["#{thor_root}/thor.yml"]
+
+      files.map! do |file|
+        File.directory?(file) ? File.join(file, "main.thor") : file
       end
-      
-      puts # add some spacing
     end
-  end
 
-  def initialize_thorfiles(relevant_to = nil)
-    thorfiles(relevant_to).each {|f| load_thorfile f unless Thor.subclass_files.keys.include?(File.expand_path(f))}
-  end
-  
-  def load_thorfile(path)
-    begin
-      load path
-    rescue Object => e
-      $stderr.puts "WARNING: unable to load thorfile #{path.inspect}: #{e.message}"
+    # Load thorfiles relevant to the given method. If you provide "foo:bar" it
+    # will load all thor files in the thor.yaml that has "foo" e "foo:bar"
+    # namespaces registered.
+    #
+    def thorfiles_relevant_to(meth)
+      lookup = [ meth, meth.split(":")[0...-1].join(":") ]
+
+      files = thor_yaml.select do |k, v|
+        v[:namespaces] && !(v[:namespaces] & lookup).empty?
+      end
+
+      files.map { |k, v| File.join(thor_root, "#{v[:filename]}") }
     end
-  end
-  
-  def thorfiles(relevant_to = nil)
-    path = Dir.pwd
-    thorfiles = []
-    
-    # Look for Thorfile or *.thor in the current directory or a parent directory, until the root
-    while thorfiles.empty?
-      thorfiles = Thor::Runner.globs_for(path).map {|g| Dir[g]}.flatten
-      path = File.dirname(path)
-      break if path == "/"
+
+    # Display information about the given klasses. If with_module is given,
+    # it shows a table with information extracted from the yaml file.
+    #
+    def display_klasses(with_modules=false, klasses=Thor.subclasses)
+      klasses -= [Thor, Thor::Runner] unless with_modules
+      raise Error, "No Thor tasks available" if klasses.empty?
+
+      if with_modules && !thor_yaml.empty?
+        info  = []
+        labels = ["Modules", "Namespaces"]
+
+        info << labels
+        info << [ "-" * labels[0].size, "-" * labels[1].size ]
+
+        thor_yaml.each do |name, hash|
+          info << [ name, hash[:namespaces].join(", ") ]
+        end
+
+        print_table info
+        say ""
+      end
+
+      unless klasses.empty?
+        klasses.each { |k| display_tasks(k) }
+      else
+        say "\033[1;34mNo Thor tasks available\033[0m"
+      end
     end
 
-    # We want to load system-wide Thorfiles first
-    # so the local Thorfiles will override them.
-    (relevant_to ? thorfiles_relevant_to(relevant_to) :
-     thor_root_glob) + thorfiles - ["#{thor_root}/thor.yml"]
-  end
+    # Display tasks from the given Thor class.
+    #
+    def display_tasks(klass)
+      unless klass.tasks.empty?
+        base = klass.namespace
 
-  def thorfiles_relevant_to(meth)
-    klass_str = Thor::Util.to_constant(meth.split(":")[0...-1].join(":"))
-    thor_yaml.select do |k, v|
-      v[:constants] && v[:constants].include?(klass_str)
-    end.map { |k, v| File.join(thor_root, "#{v[:filename]}") }
-  end
+        if base == "default"
+          say "\033[1;35m#{base}\033[0m"
+        else
+          say "\033[1;34m#{base}\033[0m"
+        end
+        say "-" * base.length
 
+        klass.help(shell, :short => true, :namespace => true)
+        say
+      end
+    end
 end