mislav-thor 0.9.5 → 0.9.10

data/CHANGELOG.rdoc

@@ -0,0 +1,52 @@
+== TODO
+
+* Change Thor.start to parse ARGV in a single pass
+* Improve spec coverage for Thor::Runner
+* Improve help output to list shorthand switches, too
+* Investigate and fix deep namespacing ("foo:bar:baz") issues
+
+== 0.9.8, released 2008-10-20
+
+* Fixed some tiny issues that were introduced lately.
+
+== 0.9.7, released 2008-10-13
+
+* Setting global method options on the initialize method works as expected:
+  All other tasks will accept these global options in addition to their own.
+* Added 'group' notion to Thor task sets (class Thor); by default all tasks
+  are in the 'standard' group. Running 'thor -T' will only show the standard
+  tasks - adding --all will show all tasks. You can also filter on a specific
+  group using the --group option: thor -T --group advanced
+  
+== 0.9.6, released 2008-09-13
+
+* Generic improvements
+
+== 0.9.5, released 2008-08-27
+
+* Improve Windows compatibility
+* Update (incorrect) README and task.thor sample file
+* Options hash is now frozen (once returned)
+* Allow magic predicates on options object. For instance: `options.force?`
+* Add support for :numeric type
+* BACKWARDS INCOMPATIBLE: Refactor Thor::Options. You cannot access shorthand forms in options hash anymore (for instance, options[:f])
+* Allow specifying optional args with default values: method_options(:user => "mislav")
+* Don't write options for nil or false values. This allows, for example, turning color off when running specs.
+* Exit with the status of the spec command to help CI stuff out some.
+
+== 0.9.4, released 2008-08-13
+
+* Try to add Windows compatibility.
+* BACKWARDS INCOMPATIBLE: options hash is now accessed as a property in your class and is not passed as last argument anymore
+* Allow options at the beginning of the argument list as well as the end.
+* Make options available with symbol keys in addition to string keys.
+* Allow true to be passed to Thor#method_options to denote a boolean option.
+* If loading a thor file fails, don't give up, just print a warning and keep going.
+* Make sure that we re-raise errors if they happened further down the pipe than we care about.
+* Only delete the old file on updating when the installation of the new one is a success
+* Make it Ruby 1.8.5 compatible.
+* Don't raise an error if a boolean switch is defined multiple times.
+* Thor::Options now doesn't parse through things that look like options but aren't.
+* Add URI detection to install task, and make sure we don't append ".thor" to URIs
+* Add rake2thor to the gem binfiles.
+* Make sure local Thorfiles override system-wide ones.

data/README.markdown

@@ -10,49 +10,67 @@ Example:
       map "-L" => :list                                               # [2]
                                                                     
       desc "install APP_NAME", "install one of the available apps"    # [3]
-      method_options :force => :boolean                               # [4]
-      def install(name, opts)
-        ... code ...
-        if opts[:force]
+      method_options :force => :boolean, :alias => :optional          # [4]
+      def install(name)
+        user_alias = options[:alias]
+        if options.force?
           # do something
         end
+        # ... other code ...
       end
       
       desc "list [SEARCH]", "list all of the available apps, limited by SEARCH"
       def list(search = "")
         # list everything
       end
-      
     end
     
-    MyApp.start
-    
-Thor automatically maps commands as follows:
+Thor automatically maps commands as such:
 
-    app install name --force
+    app install myname --force
     
 That gets converted to:
 
-    MyApp.new.install("name", :force => true)
+    MyApp.new.install("myname")
+    # with {'force' => true} as options hash
 
 1.  Inherit from Thor to turn a class into an option mapper
 2.  Map additional non-valid identifiers to specific methods. In this case,
     convert -L to :list
 3.  Describe the method immediately below. The first parameter is the usage information,
     and the second parameter is the description.
-4.  Provide any additional options. These will be marshaled from -- and - params.
-    In this case, a --force and a -f option is added.
+4.  Provide any additional options. These will be marshaled from `--` and `-` params.
+    In this case, a `--force` and a `-f` option is added.
     
 Types for `method_options`
 --------------------------
 
 <dl>
   <dt><code>:boolean</code></dt>
-  <dd>true if the option is passed</dd>
+    <dd>true if the option is passed</dd>
+  <dt><code>true or false</code></dt>
+    <dd>same as <code>:boolean</code>, but fall back to given boolean as default value</dd>
   <dt><code>:required</code></dt>
-  <dd>the value for this option MUST be provided</dd>
+    <dd>the value for this option MUST be provided</dd>
   <dt><code>:optional</code></dt>
-  <dd>the value for this option MAY be provided</dd>
-  <dt>a String</dt>
-  <dd>same as <code>:optional</code>; fall back to the given string as default value</dd>
-</dl>
+    <dd>the value for this option MAY be provided</dd>
+  <dt><code>:numeric</code></dt>
+    <dd>the value MAY be provided, but MUST be in numeric form</dd>
+  <dt>a String or Numeric</dt>
+    <dd>same as <code>:optional</code>, but fall back to the given object as default value</dd>
+</dl>
+
+In case of unsatisfied requirements, `Thor::Options::Error` is raised.
+
+Examples of option parsing:
+
+    # let's say this is how we defined options for a method:
+    method_options(:force => :boolean, :retries => :numeric)
+    
+    # here is how the following command-line invocations would be parsed:
+    
+    command -f --retries 5    # => {'force' => true, 'retries' => 5}
+    command --force -r=5      # => {'force' => true, 'retries' => 5}
+    command -fr 5             # => {'force' => true, 'retries' => 5}
+    command --retries=5       # => {'retries' => 5}
+    command -r5               # => {'retries' => 5}

data/Rakefile

@@ -2,5 +2,5 @@ task :default => :install
 
 desc "install the gem locally"
 task :install do
-  sh %{ruby #{File.dirname(__FILE__)}/bin/thor :install}
+  sh %{ruby "#{File.dirname(__FILE__)}/bin/thor" :install}
 end

data/lib/thor.rb

@@ -7,6 +7,13 @@ require "thor/task_hash"
 class Thor
   attr_accessor :options
   
+  def self.default_task(meth=nil)
+    unless meth.nil?
+      @default_task = (meth == :none) ? 'help' : meth.to_s
+    end
+    @default_task ||= (self == Thor ? 'help' : superclass.default_task)
+  end
+    
   def self.map(map)
     @map ||= superclass.instance_variable_get("@map") || {}
     map.each do |key, value|
@@ -22,10 +29,16 @@ class Thor
     @usage, @desc = usage, description
   end
   
+  def self.group(name)
+    @group_name = name.to_s
+  end
+  
+  def self.group_name
+    @group_name || 'standard'
+  end
+  
   def self.method_options(opts)
-    @method_options = opts.inject({}) do |accum, (k,v)|
-      accum.merge("--" + k.to_s => v)
-    end
+    @method_options = (@method_options || {}).merge(opts)
   end
 
   def self.subclass_files
@@ -55,25 +68,42 @@ class Thor
     @maxima ||= begin
       max_usage = tasks.map {|_, t| t.usage}.max {|x,y| x.to_s.size <=> y.to_s.size}.size
       max_desc  = tasks.map {|_, t| t.description}.max {|x,y| x.to_s.size <=> y.to_s.size}.size
-      max_opts  = tasks.map {|_, t| t.formatted_opts}.max {|x,y| x.to_s.size <=> y.to_s.size}.size
+      max_opts  = tasks.map {|_, t| t.opts ? t.opts.formatted_usage : ""}.max {|x,y| x.to_s.size <=> y.to_s.size}.size
       Struct.new(:description, :usage, :opt).new(max_desc, max_usage, max_opts)
     end
   end
   
   def self.start(args = ARGV)
-    options = Thor::Options.new(args, self.opts)
-    opts = options.getopts
-    args = options.args
+    
+    options = Thor::Options.new(self.opts)
+    opts = options.parse(args, false)
+    args = options.trailing_non_opts
 
     meth = args.first
     meth = @map[meth].to_s if @map && @map[meth]
-    meth ||= "help"
+    meth ||= default_task
+    meth = meth.to_s.gsub('-','_') # treat foo-bar > foo_bar
     
     tasks[meth].parse new(opts, *args), args[1..-1]
   rescue Thor::Error => e
     $stderr.puts e.message
   end
+  
+  # Invokes a specific task.  You can use this method instead of start() 
+  # to run a thor task if you know the specific task you want to invoke.
+  def self.invoke(task_name=nil, args = ARGV)
+    args = args.dup
+    args.unshift(task_name || default_task)
+    start(args)
+  end
 
+  # Main entry point method that should actually invoke the method.  You
+  # can override this to provide some class-wide processing.  The default
+  # implementation simply invokes the named method
+  def invoke(meth, *args)
+    self.send(meth, *args)
+  end
+  
   class << self
     protected
     def inherited(klass)
@@ -82,7 +112,7 @@ class Thor
 
     def method_added(meth)
       meth = meth.to_s
-
+      
       if meth == "initialize"
         @opts = @method_options
         @method_options = nil
@@ -126,15 +156,14 @@ class Thor
 
       puts task.formatted_usage(namespace)
       puts task.description
-      return
-    end
-
-    puts "Options"
-    puts "-------"
-    self.class.tasks.each do |_, task|
-      format = "%-" + (self.class.maxima.usage + self.class.maxima.opt + 4).to_s + "s"
-      print format % ("#{task.formatted_usage}")      
-      puts  task.description.split("\n").first
+    else
+      puts "Options"
+      puts "-------"
+      self.class.tasks.each do |_, task|
+        puts task.formatted_usage
+        puts ' ' * 4 + task.description.split("\n").first
+        puts
+      end
     end
   end
   

data/lib/thor/options.rb

@@ -1,57 +1,55 @@
-# This is a modified version of Daniel Berger's Getopt::ong class,
+# This is a modified version of Daniel Berger's Getopt::Long class,
 # licensed under Ruby's license.
 
-require 'set'
-
 class Thor
   class Options
     class Error < StandardError; end
-
-    LONG_RE     = /^(--\w+[-\w+]*)$/
-    SHORT_RE    = /^(-\w)$/
-    LONG_EQ_RE  = /^(--\w+[-\w+]*)=(.*?)$|(-\w?)=(.*?)$/
-    SHORT_SQ_RE = /^-(\w\S+?)$/ # Allow either -x -v or -xv style for single char args
-
-    attr_accessor :args
-
-    def initialize(args, switches)
-      @args = args
-      @defaults = {}
-
-      switches = switches.map do |names, type|
-        case type
-        when TrueClass then type = :boolean
-        when String
-          @defaults[names] = type
-          type = :optional
-        end
-
-        if names.is_a?(String)
-          if names =~ LONG_RE
-            names = [names, "-" + names[2].chr]
-          else
-            names = [names]
-          end
-        end
-
-        [names, type]
+    
+    # simple Hash with indifferent access
+    class Hash < ::Hash
+      def initialize(hash)
+        super()
+        update hash
       end
-
-      @valid = switches.map {|s| s.first}.flatten.to_set
-      @types = switches.inject({}) do |h, (forms,v)|
-        forms.each {|f| h[f] ||= v}
-        h
+      
+      def [](key)
+        super convert_key(key)
       end
-      @syns = switches.inject({}) do |h, (forms,_)|
-        forms.each {|f| h[f] ||= forms}
-        h
+      
+      def values_at(*indices)
+        indices.collect { |key| self[convert_key(key)] }
       end
+      
+      protected
+        def convert_key(key)
+          key.kind_of?(Symbol) ? key.to_s : key
+        end
+        
+        # Magic predicates. For instance:
+        #   options.force? # => !!options['force']
+        def method_missing(method, *args, &block)
+          method = method.to_s
+          if method =~ /^(\w+)=$/ 
+            self[$1] = args.first
+          elsif method =~ /^(\w+)\?$/
+            !!self[$1]
+          else 
+            self[method]
+          end
+        end
     end
 
-    def skip_non_opts
-      non_opts = []
-      non_opts << pop until looking_at_opt? || @args.empty?
-      non_opts
+    NUMERIC     = /(\d*\.\d+|\d+)/
+    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
+    
+    attr_reader :leading_non_opts, :trailing_non_opts
+    
+    def non_opts
+      leading_non_opts + trailing_non_opts
     end
 
     # Takes an array of switches. Each array consists of up to three
@@ -65,92 +63,205 @@ class Thor
     #
     # Example:
     #
-    # opts = Thor::Options.new(args,
-    #    "--debug" => true,
-    #    ["--verbose", "-v"] => true,
-    #    ["--level", "-l"] => :numeric
-    # ).getopts
+    #   opts = Thor::Options.new(
+    #      "--debug" => true,
+    #      ["--verbose", "-v"] => true,
+    #      ["--level", "-l"] => :numeric
+    #   ).parse(args)
     #
-    def getopts(check_required = true)
-      hash = @defaults.dup
+    def initialize(switches)
+      @defaults = {}
+      @shorts = {}
+      
+      @leading_non_opts, @trailing_non_opts = [], []
+
+      @switches = switches.inject({}) do |mem, (name, type)|
+        if name.is_a?(Array)
+          name, *shorts = name
+        else
+          name = name.to_s
+          shorts = []
+        end
+        # we need both nice and dasherized form of switch name
+        if name.index('-') == 0
+          nice_name = undasherize name
+        else
+          nice_name = name
+          name = dasherize name
+        end
+        # if there are no shortcuts specified, generate one using the first character
+        shorts << "-" + nice_name[0,1] if shorts.empty? and nice_name.length > 1
+        shorts.each { |short| @shorts[short] = name }
+        
+        # normalize type
+        case type
+        when TrueClass
+          @defaults[nice_name] = true
+          type = :boolean
+        when FalseClass
+          @defaults[nice_name] = false
+          type = :boolean
+        when String
+          @defaults[nice_name] = type
+          type = :optional
+        when Numeric
+          @defaults[nice_name] = type
+          type = :numeric
+        end
+        
+        mem[name] = type
+        mem
+      end
+      
+      # remove shortcuts that happen to coincide with any of the main switches
+      @shorts.keys.each do |short|
+        @shorts.delete(short) if @switches.key?(short)
+      end
+    end
 
-      while looking_at_opt?
-        case pop
+    def parse(args, skip_leading_non_opts = true)
+      @args = args
+      # start with Thor::Options::Hash pre-filled with defaults
+      hash = Hash.new @defaults
+      
+      @leading_non_opts = []
+      if skip_leading_non_opts
+        @leading_non_opts << shift until current_is_option? || @args.empty?
+      end
+
+      while current_is_option?
+        case shift
         when SHORT_SQ_RE
-          push(*$1.split("").map {|s| s = "-#{s}"})
-          next
-        when LONG_EQ_RE
-          push($1, $2)
+          unshift $1.split('').map { |f| "-#{f}" }
           next
+        when EQ_RE, SHORT_NUM
+          unshift $2
+          switch = $1
         when LONG_RE, SHORT_RE
           switch = $1
         end
-
-        case @types[switch]
+        
+        switch    = normalize_switch(switch)
+        nice_name = undasherize(switch)
+        type      = switch_type(switch)
+        
+        case type
         when :required
-          raise Error, "no value provided for required argument '#{switch}'" if peek.nil?
-          raise Error, "cannot pass switch '#{peek}' as an argument" if @valid.include?(peek)
-          hash[switch] = pop
-        when :boolean
-          hash[switch] = true
+          assert_value!(switch)
+          raise Error, "cannot pass switch '#{peek}' as an argument" if valid?(peek)
+          hash[nice_name] = shift
         when :optional
-          # For optional arguments, there may be an argument.  If so, it
-          # cannot be another switch.  If not, it is set to true.
-          hash[switch] = @valid.include?(peek) || peek.nil? || pop
+          hash[nice_name] = peek.nil? || valid?(peek) || shift
+        when :boolean
+          if !@switches.key?(switch) && nice_name =~ /^no-(\w+)$/
+            hash[$1] = false
+          else
+            hash[nice_name] = true
+          end
+          
+        when :numeric
+          assert_value!(switch)
+          unless peek =~ NUMERIC and $& == peek
+            raise Error, "expected numeric value for '#{switch}'; got #{peek.inspect}"
+          end
+          hash[nice_name] = $&.index('.') ? shift.to_f : shift.to_i
         end
       end
+      
+      @trailing_non_opts = @args
 
-      hash = normalize_hash hash
-      check_required_args hash if check_required
+      check_required! hash
+      hash.freeze
       hash
     end
-
-    def check_required_args(hash)
-      @types.select {|k,v| v == :required}.map {|k,v| @syns[k]}.uniq.each do |syns|
-        unless syns.map {|s| s.gsub(/^-+/, '')}.any? {|s| hash[s]}
-          raise Error, "no value provided for required argument '#{syns.first}'"
+    
+    def formatted_usage
+      return "" if @switches.empty?
+      @switches.map do |opt, type|
+        case type
+        when :boolean
+          "[#{opt}]"
+        when :required
+          opt + "=" + opt.gsub(/\-/, "").upcase
+        else
+          sample = @defaults[undasherize(opt)]
+          sample ||= case type
+            when :optional then undasherize(opt).gsub(/\-/, "_").upcase
+            when :numeric  then "N"
+            end
+          "[" + opt + "=" + sample.to_s + "]"
         end
-      end
+      end.join(" ")
     end
+    
+    alias :to_s :formatted_usage
 
     private
-
+    
+    def assert_value!(switch)
+      raise Error, "no value provided for argument '#{switch}'" if peek.nil?
+    end
+    
+    def undasherize(str)
+      str.sub(/^-{1,2}/, '')
+    end
+    
+    def dasherize(str)
+      (str.length > 1 ? "--" : "-") + str
+    end
+    
     def peek
       @args.first
     end
 
-    def pop
-      arg = peek
-      @args = @args[1..-1] || []
-      arg
+    def shift
+      @args.shift
     end
 
-    def push(*args)
-      @args = args + @args
+    def unshift(arg)
+      unless arg.kind_of?(Array)
+        @args.unshift(arg)
+      else
+        @args = arg + @args
+      end
+    end
+    
+    def valid?(arg)
+      if arg.to_s =~ /^--no-(\w+)$/
+        @switches.key?(arg) or (@switches["--#{$1}"] == :boolean)
+      else
+        @switches.key?(arg) or @shorts.key?(arg)
+      end
     end
 
-    def looking_at_opt?
+    def current_is_option?
       case peek
-      when LONG_RE, SHORT_RE, LONG_EQ_RE
-        @valid.include? $1
+      when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM
+        valid?($1)
       when SHORT_SQ_RE
-        $1.split("").any? {|f| @valid.include? "-#{f}"}
+        $1.split('').any? { |f| valid?("-#{f}") }
       end
     end
-
-    # Set synonymous switches to the same value, e.g. if -t is a synonym
-    # for --test, and the user passes "--test", then set "-t" to the same
-    # value that "--test" was set to.
-    #
-    # This allows users to refer to the long or short switch and get
-    # the same value
-    def normalize_hash(hash)
-      hash.map do |switch, val|
-        @syns[switch].map {|key| [key, val]}
-      end.inject([]) {|a, v| a + v}.map do |key, value|
-        [key.sub(/^-+/, ''), value]
-      end.inject({}) {|h, (k,v)| h[k] = v; h[k.to_sym] = v; h}
+    
+    def normalize_switch(switch)
+      @shorts.key?(switch) ? @shorts[switch] : switch
     end
-
+    
+    def switch_type(switch)
+      if switch =~ /^--no-(\w+)$/
+        @switches[switch] || @switches["--#{$1}"]
+      else
+        @switches[switch]
+      end
+    end
+    
+    def check_required!(hash)
+      for name, type in @switches
+        if type == :required and !hash[undasherize(name)]
+          raise Error, "no value provided for required argument '#{name}'"
+        end
+      end
+    end
+    
   end
 end

data/lib/thor/runner.rb

@@ -18,8 +18,17 @@ class Thor::Runner < Thor
   method_options :as => :optional, :relative => :boolean
   def install(name)
     initialize_thorfiles
+
+    base = name
+    package = :file
+
     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
+        contents = open(name).read
+      end
     rescue OpenURI::HTTPError
       raise Error, "Error opening URI `#{name}'"
     rescue Errno::ENOENT
@@ -35,9 +44,7 @@ class Thor::Runner < Thor
     
     return false unless response =~ /^\s*y/i
     
-    constants = Thor::Util.constants_in_contents(contents)
-    
-    # name = name =~ /\.thor$/ || is_uri ? name : "#{name}.thor"
+    constants = Thor::Util.constants_in_contents(contents, base)
     
     as = options["as"] || begin
       first_line = contents.split("\n")[0]
@@ -63,8 +70,12 @@ class Thor::Runner < Thor
     
     puts "Storing thor file in your system repository"
     
-    File.open(File.join(thor_root, yaml[as][:filename]), "w") do |file|
-      file.puts contents
+    destination = File.join(thor_root, 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
@@ -78,7 +89,7 @@ class Thor::Runner < Thor
     puts "Uninstalling #{name}."
     
     file = File.join(thor_root, "#{yaml[name][:filename]}")
-    File.delete(file)
+    FileUtils.rm_rf(file)
     yaml.delete(name)
     save_yaml(yaml)
     
@@ -92,7 +103,7 @@ class Thor::Runner < Thor
 
     puts "Updating `#{name}' from #{yaml[name][:location]}"
     old_filename = yaml[name][:filename]
-    options["as"] = name
+    self.options = self.options.merge("as" => name)
     filename = install(yaml[name][:location])
     unless filename == old_filename
       File.delete(File.join(thor_root, old_filename))
@@ -102,7 +113,7 @@ class Thor::Runner < Thor
   desc "installed", "list the installed Thor modules and tasks (--internal means list the built-in tasks as well)"
   method_options :internal => :boolean
   def installed
-    Dir["#{thor_root}/**/*"].each do |f|
+    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
@@ -113,14 +124,21 @@ class Thor::Runner < Thor
   end
   
   desc "list [SEARCH]", "list the available thor tasks (--substring means SEARCH can be anywhere in the module)"
-  method_options :substring => :boolean
+  method_options :substring => :boolean,
+                 :group => :optional,
+                 :all => :boolean,
+                 ['--descriptions', '-D'] => :boolean
   def list(search = "")
     initialize_thorfiles
     search = ".*#{search}" if options["substring"]
     search = /^#{search}.*/i
-    
-    display_klasses(false, Thor.subclasses.select {|k| 
-      Thor::Util.constant_to_thor_path(k.name) =~ search})
+    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
+    end
+    display_klasses(false, classes, options.descriptions?)
   end
 
   # Override Thor#help so we can give info about not-yet-loaded tasks
@@ -141,11 +159,27 @@ class Thor::Runner < Thor
   def self.thor_root
     File.join(ENV["HOME"] || ENV["APPDATA"], ".thor")
   end
+
+  def self.thor_root_glob
+    # On Windows thor_root will be something like this:
+    #
+    #   C:\Documents and Settings\james\.thor
+    #
+    # If we don't #gsub the \ character, Dir.glob will fail.
+    files = Dir["#{thor_root.gsub(/\\/, '/')}/*"]
+    files.map! do |file|
+      File.directory?(file) ? File.join(file, "main.thor") : file
+    end
+  end
   
   private
   def thor_root
     self.class.thor_root
   end
+
+  def thor_root_glob
+    self.class.thor_root_glob
+  end
   
   def thor_yaml
     yaml_file = File.join(thor_root, "thor.yml")
@@ -158,12 +192,12 @@ class Thor::Runner < Thor
     File.open(yaml_file, "w") {|f| f.puts yaml.to_yaml }
   end
   
-  def display_klasses(with_modules = false, klasses = Thor.subclasses)
+  def display_klasses(with_modules = false, klasses = Thor.subclasses, show_descriptions = false)
     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.size <=> yk.size }.first.size
+      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
@@ -181,30 +215,41 @@ class Thor::Runner < Thor
       puts
     end
     
-    puts "Tasks"
-    puts "-----"
-    
-    # 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
+    unless klasses.empty?
+      puts # add some spacing
+      klasses.each { |klass| display_tasks(klass, show_descriptions) }
+    else
+      puts "\033[1;34mNo Thor tasks available\033[0m"
     end
-    
-    max_left = max_left_item.maxima.usage + max_left_item.maxima.opt
-        
-    klasses.each {|k| display_tasks(k, max_base, max_left)}
   end  
   
-  def display_tasks(klass, max_base, max_left)
-    base = Thor::Util.constant_to_thor_path(klass.name)
-    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
+  def display_tasks(klass, show_descriptions)
+    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"
+      end
+      puts "-" * base.length
+      
+      klass.tasks.each true do |name, task|
+        puts task.formatted_usage(true)
+        if show_descriptions
+          puts ' ' * 4 + task.description
+          puts
+        end
+      end
+      
+      puts unless show_descriptions
+      
+      unless klass.opts.empty?
+        puts "\nglobal options: #{Options.new(klass.opts)}"
+        puts # add some spacing
+      end
     end
   end
 
@@ -213,8 +258,9 @@ class Thor::Runner < Thor
   end
   
   def load_thorfile(path)
+    txt = File.read(path)
     begin
-      load path
+      Thor::Tasks.class_eval txt, path
     rescue Object => e
       $stderr.puts "WARNING: unable to load thorfile #{path.inspect}: #{e.message}"
     end
@@ -233,8 +279,12 @@ class Thor::Runner < Thor
 
     # We want to load system-wide Thorfiles first
     # so the local Thorfiles will override them.
-    (relevant_to ? thorfiles_relevant_to(relevant_to) :
-     Dir["#{thor_root}/**/*"]) + thorfiles - ["#{thor_root}/thor.yml"]
+    files = (relevant_to ? thorfiles_relevant_to(relevant_to) :
+     thor_root_glob) + thorfiles - ["#{thor_root}/thor.yml"]
+     
+    files.map! do |file|
+      File.directory?(file) ? File.join(file, "main.thor") : file
+    end
   end
 
   def thorfiles_relevant_to(meth)

data/lib/thor/task.rb

@@ -3,9 +3,16 @@ require 'thor/util'
 
 class Thor
   class Task < Struct.new(:meth, :description, :usage, :opts, :klass)
+    
     def self.dynamic(meth, klass)
       new(meth, "A dynamically-generated task", meth.to_s, nil, klass)
     end
+    
+    def initialize(*args)
+      # keep the original opts - we need them later on
+      @options = args[3] || {}
+      super
+    end
 
     def parse(obj, args)
       list, hash = parse_args(args)
@@ -17,14 +24,18 @@ class Thor
       raise NoMethodError, "the `#{meth}' task of #{obj.class} is private" if
         (obj.private_methods + obj.protected_methods).include?(meth)
       
-      obj.send(meth, *params)
+      obj.invoke(meth, *params)
     rescue ArgumentError => e
+      
       # backtrace sans anything in this file
       backtrace = e.backtrace.reject {|frame| frame =~ /^#{Regexp.escape(__FILE__)}/}
+      # also nix anything in thor.rb
+      backtrace = backtrace.reject { |frame| frame =~ /\/thor.rb/ }
+      
       # and sans anything that got us here
       backtrace -= caller
       raise e unless backtrace.empty?
-    
+      
       # okay, they really did call it wrong
       raise Error, "`#{meth}' was called incorrectly. Call as `#{formatted_usage}'"
     rescue NoMethodError => e
@@ -45,35 +56,27 @@ class Thor
       new.klass = klass
       new
     end
-
-    def formatted_opts
-      return "" if opts.nil?
-      opts.map do |opt, val|
-        if val == true || val == :boolean
-          "[#{opt}]"
-        elsif val == :required
-          opt + "=" + opt.gsub(/\-/, "").upcase
-        else
-          sample = val == :optional ? opt.gsub(/\-/, "").upcase : val
-          "[" + opt + "=" + sample + "]"
-        end
-      end.join(" ")
+    
+    def opts
+      return super unless super.kind_of? Hash
+      @_opts ||= Options.new(super)
     end
-
+        
+    def full_opts
+      @_full_opts ||= Options.new((klass.opts || {}).merge(@options))
+    end
+    
     def formatted_usage(namespace = false)
       (namespace ? self.namespace + ':' : '') + usage +
-        (opts ? " " + formatted_opts : "")
+        (opts ? " " + opts.formatted_usage : "")
     end
 
     protected
 
     def parse_args(args)
-      return [args, {}] unless opts
-      options = Thor::Options.new(args, opts)
-      hash = options.getopts(false)
-      list = options.skip_non_opts
-      hash.update options.getopts(false)
-      options.check_required_args hash
+      return [[], {}] if args.nil?
+      hash = full_opts.parse(args)
+      list = full_opts.non_opts
       [list, hash]
     end
   end

data/lib/thor/tasks.rb

@@ -13,13 +13,16 @@ class Thor
   
   def self.install_task(spec)
     package_task spec
+
+    null, sudo, gem = RUBY_PLATFORM =~ /w(in)?32$/ ? ['NUL', '', 'gem.bat'] :
+                                                     ['/dev/null', 'sudo', 'gem']
     
     desc "install", "install the gem"
     define_method :install do
-      old_stderr, $stderr = $stderr.dup, File.open("/dev/null", "w")
+      old_stderr, $stderr = $stderr.dup, File.open(null, "w")
       package
       $stderr = old_stderr
-      system %{sudo gem install pkg/#{spec.name}-#{spec.version} --no-rdoc --no-ri --no-update-sources}
+      system %{#{sudo} #{Gem.ruby} -S #{gem} install pkg/#{spec.name}-#{spec.version} --no-rdoc --no-ri --no-update-sources}
     end
   end
   

data/lib/thor/util.rb

@@ -1,10 +1,38 @@
 require 'thor/error'
 
+module ObjectSpace
+  
+  class << self
+
+    # @return <Array[Class]> All the classes in the object space.
+    def classes
+      klasses = []
+      ObjectSpace.each_object(Class) {|o| klasses << o}
+      klasses
+    end
+  end
+  
+end
+
 class Thor
+  module Tasks; end
+  
   module Util
     
+    def self.full_const_get(obj, name)
+      list = name.split("::")
+      list.shift if list.first.empty?
+      list.each do |x| 
+        # This is required because const_get tries to look for constants in the 
+        # ancestor chain, but we only want constants that are HERE
+        obj = obj.const_defined?(x) ? obj.const_get(x) : obj.const_missing(x)
+      end
+      obj
+    end
+    
     def self.constant_to_thor_path(str, remove_default = true)
-      str = snake_case(str.to_s).squeeze(":")
+      str = str.to_s.gsub(/^Thor::Tasks::/, "")
+      str = snake_case(str).squeeze(":")
       str.gsub!(/^default/, '') if remove_default
       str
     end
@@ -21,16 +49,20 @@ class Thor
       str.gsub(/:(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
     end
 
-    def self.constants_in_contents(str)
-      klasses = self.constants.dup
-      eval(str)
-      ret = self.constants - klasses
-      ret.each {|k| self.send(:remove_const, k)}
-      ret
+    def self.constants_in_contents(str, file = __FILE__)
+      klasses = ObjectSpace.classes.dup
+      Module.new.class_eval(str, file)
+      klasses = ObjectSpace.classes - klasses
+      klasses = klasses.select {|k| k < Thor }
+      klasses.map! {|k| k.to_s.gsub(/#<Module:\w+>::/, '')}
     end
 
-    def self.make_constant(str)
-      list = str.split("::").inject(Object) {|obj, x| obj.const_get(x)}
+    def self.make_constant(str, base = [Thor::Tasks, Object])
+      which = base.find do |obj|
+        full_const_get(obj, str) rescue nil
+      end
+      return full_const_get(which, str) if which
+      raise NameError, "uninitialized constant #{str}"
     end
     
     def self.snake_case(str)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mislav-thor
 version: !ruby/object:Gem::Version 
-  version: 0.9.5
+  version: 0.9.10
 platform: ruby
 authors: 
 - Yehuda Katz
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-25 00:00:00 -07:00
+date: 2009-01-27 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -23,9 +23,11 @@ extensions: []
 extra_rdoc_files: 
 - README.markdown
 - LICENSE
+- CHANGELOG.rdoc
 files: 
-- LICENSE
 - README.markdown
+- LICENSE
+- CHANGELOG.rdoc
 - Rakefile
 - bin/rake2thor
 - bin/thor