wycats-thor 0.9.2

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Yehuda Katz
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,59 @@
+thor
+====
+
+Map options to a class. Simply create a class with the appropriate annotations, and have options automatically map
+to functions and parameters.
+
+Examples:
+
+    class MyApp < Thor                                                        # [1]
+      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]
+          # do something
+        end
+      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:
+
+    app install name --force
+    
+That gets converted to:
+
+    MyApp.new.install("name", :force => true)
+  
+[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.
+    
+Types for `method_options`
+--------------------------
+
+<dl>
+  <dt>:boolean</dt>
+  <dd>true if the option is passed</dd>
+  <dt>:required</dt>
+  <dd>A key/value option that MUST be provided</dd>
+  <dt>:optional</dt>
+  <dd>A key/value option that MAY be provided</dd>
+</dl>

data/Rakefile

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

data/bin/rake2thor

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'ruby2ruby'
+require 'rake'
+
+input  = ARGV[0] || 'Rakefile'
+output = ARGV[1] || 'Thorfile'
+
+$requires = []
+
+module Kernel
+  def require_with_record(file)
+    $requires << file if caller[1] =~ /rake2thor:/
+    require_without_record file
+  end
+  alias_method :require_without_record, :require
+  alias_method :require, :require_with_record
+end
+
+load input
+
+@private_methods = []
+
+def file_task_name(name)
+  "compile_" + name.gsub('/', '_slash_').gsub('.', '_dot_').gsub(/\W/, '_')
+end
+
+def method_for_task(task)
+  file_task = task.is_a?(Rake::FileTask)
+  comment = task.instance_variable_get('@comment')
+  prereqs = task.instance_variable_get('@prerequisites').select(&Rake::Task.method(:task_defined?))
+  actions = task.instance_variable_get('@actions')
+  name = task.name.gsub(/^([^:]+:)+/, '')
+  name = file_task_name(name) if file_task
+  meth = ''
+
+  meth << "desc #{name.inspect}, #{comment.inspect}\n" if comment
+  meth << "def #{name}\n"
+
+  meth << prereqs.map do |pre|
+    pre = pre.to_s
+    pre = file_task_name(pre) if Rake::Task[pre].is_a?(Rake::FileTask)
+    '  ' + pre
+  end.join("\n")
+
+  meth << "\n\n" unless prereqs.empty? || actions.empty?
+
+  meth << actions.map do |act|
+    act = act.to_ruby
+    unless act.gsub!(/^proc \{ \|(\w+)\|\n/,
+                     "  \\1 = Struct.new(:name).new(#{name.inspect}) # A crude mock Rake::Task object\n")
+      act.gsub!(/^proc \{\n/, '')
+    end
+    act.gsub(/\n\}$/, '')
+  end.join("\n")
+
+  meth << "\nend"
+
+  if file_task
+    @private_methods << meth
+    return
+  end
+
+  meth
+end
+
+body = Rake::Task.tasks.map(&method(:method_for_task)).compact.map { |meth| meth.gsub(/^/, '  ') }.join("\n\n")
+
+unless @private_methods.empty?
+  body << "\n\n  private\n\n"
+  body << @private_methods.map { |meth| meth.gsub(/^/, '  ') }.join("\n\n")
+end
+
+requires = $requires.map { |r| "require #{r.inspect}" }.join("\n")
+
+File.open(output, 'w') { |f| f.write(<<END.lstrip) }
+#{requires}
+
+class Default < Thor
+#{body}
+end
+END

data/bin/thor

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby -*-
+
+require File.dirname(__FILE__) + "/../lib/thor"
+require 'thor/runner'
+
+Thor::Runner.start

data/lib/getopt.rb

@@ -0,0 +1,238 @@
+# The last time the Getopt gem was modified was August 2007, so it's safe to vendor (it does everything we need)
+
+module Getopt
+
+   REQUIRED  = 0
+   BOOLEAN   = 1
+   OPTIONAL  = 2
+   INCREMENT = 3
+   NEGATABLE = 4
+   NUMERIC   = 5
+
+   class Long
+      class Error < StandardError; end
+
+      VERSION = '1.3.6'
+
+      # Takes an array of switches. Each array consists of up to three
+      # elements that indicate the name and type of switch. Returns a hash
+      # containing each switch name, minus the '-', as a key. The value
+      # for each key depends on the type of switch and/or the value provided
+      # by the user.
+      #
+      # The long switch _must_ be provided. The short switch defaults to the
+      # first letter of the short switch. The default type is BOOLEAN.
+      #
+      # Example:
+      #
+      # opts = Getopt::Long.getopts(
+      #    ["--debug"],
+      #    ["--verbose", "-v"],
+      #    ["--level", "-l", NUMERIC]
+      # )
+      #
+      # See the README file for more information.
+      #
+      def self.getopts(*switches)
+         if switches.empty?
+            raise ArgumentError, "no switches provided"
+         end
+
+         hash  = {} # Hash returned to user
+         valid = [] # Tracks valid switches
+         types = {} # Tracks argument types
+         syns  = {} # Tracks long and short arguments, or multiple shorts
+
+         # If a string is passed, split it and convert it to an array of arrays
+         if switches.first.kind_of?(String)
+            switches = switches.join.split
+            switches.map!{ |switch| switch = [switch] }
+         end
+
+         # Set our list of valid switches, and proper types for each switch
+         switches.each{ |switch|
+            valid.push(switch[0])       # Set valid long switches
+
+            # Set type for long switch, default to BOOLEAN.
+            if switch[1].kind_of?(Fixnum)
+               switch[2] = switch[1]
+               types[switch[0]] = switch[2]
+               switch[1] = switch[0][1..2]
+            else
+               switch[2] ||= BOOLEAN
+               types[switch[0]] = switch[2]
+               switch[1] ||= switch[0][1..2]
+            end
+
+            # Create synonym hash.  Default to first char of long switch for 
+            # short switch, e.g. "--verbose" creates a "-v" synonym.  The same
+            # synonym can only be used once - first one wins.
+            syns[switch[0]] = switch[1] unless syns[switch[1]]
+            syns[switch[1]] = switch[0] unless syns[switch[1]]
+
+            switch[1].each{ |char|      
+               types[char] = switch[2]  # Set type for short switch
+               valid.push(char)         # Set valid short switches
+            }
+
+            if ARGV.empty? && switch[2] == REQUIRED
+              raise Error, "no value provided for required argument '#{switch[0]}'"
+            end            
+         }
+
+         re_long     = /^(--\w+[-\w+]*)?$/
+         re_short    = /^(-\w)$/
+         re_long_eq  = /^(--\w+[-\w+]*)?=(.*?)$|(-\w?)=(.*?)$/
+         re_short_sq = /^(-\w)(\S+?)$/
+
+         ARGV.each_with_index{ |opt, index|
+
+            # Allow either -x -v or -xv style for single char args
+            if re_short_sq.match(opt)
+               chars = opt.split("")[1..-1].map{ |s| s = "-#{s}" }
+
+               chars.each_with_index{ |char, i|
+                  unless valid.include?(char)  
+                     raise Error, "invalid switch '#{char}'"
+                  end
+
+                  # Grab the next arg if the switch takes a required arg
+                  if types[char] == REQUIRED
+                     # Deal with a argument squished up against switch
+                     if chars[i+1]
+                        arg = chars[i+1..-1].join.tr("-","")
+                        ARGV.push(char, arg)
+                        break
+                     else
+                        arg = ARGV.delete_at(index+1)
+                        if arg.nil? || valid.include?(arg) # Minor cheat here
+                           err = "no value provided for required argument '#{char}'"
+                           raise Error, err
+                        end
+                        ARGV.push(char, arg)
+                     end
+                  elsif types[char] == OPTIONAL
+                     if chars[i+1] && !valid.include?(chars[i+1])
+                        arg = chars[i+1..-1].join.tr("-","")
+                        ARGV.push(char, arg)
+                        break
+                     elsif
+                        if ARGV[index+1] && !valid.include?(ARGV[index+1])
+                           arg = ARGV.delete_at(index+1)
+                           ARGV.push(char, arg)
+                        end
+                     else
+                        ARGV.push(char)
+                     end
+                  else
+                     ARGV.push(char)
+                  end
+               }
+               next
+            end
+
+            if match = re_long.match(opt) || match = re_short.match(opt)
+               switch = match.captures.first
+            end
+
+            if match = re_long_eq.match(opt)
+               switch, value = match.captures.compact
+               ARGV.push(switch, value)
+               next
+            end
+
+            # Make sure that all the switches are valid.  If 'switch' isn't
+            # defined at this point, it means an option was passed without
+            # a preceding switch, e.g. --option foo bar.
+            unless valid.include?(switch)
+               switch ||= opt
+               raise Error, "invalid switch '#{switch}'"
+            end
+
+            # Required arguments
+            if types[switch] == REQUIRED
+               nextval = ARGV[index+1]
+
+               # Make sure there's a value for mandatory arguments
+               if nextval.nil?
+                  err = "no value provided for required argument '#{switch}'"
+                  raise Error, err
+               end
+
+               # If there is a value, make sure it's not another switch
+               if valid.include?(nextval)
+                  err = "cannot pass switch '#{nextval}' as an argument"
+                  raise Error, err
+               end
+
+               # If the same option appears more than once, put the values
+               # in array.
+               if hash[switch]
+                  hash[switch] = [hash[switch], nextval].flatten
+               else
+                  hash[switch] = nextval
+               end
+               ARGV.delete_at(index+1)
+            end
+
+            # For boolean arguments set the switch's value to true.
+            if types[switch] == BOOLEAN
+               if hash.has_key?(switch)
+                  raise Error, "boolean switch already set"
+               end
+               hash[switch] = true
+            end
+
+            # For increment arguments, set the switch's value to 0, or
+            # increment it by one if it already exists.
+            if types[switch] == INCREMENT
+               if hash.has_key?(switch)
+                  hash[switch] += 1
+               else
+                  hash[switch] = 1
+               end
+            end
+
+            # For optional argument, there may be an argument.  If so, it
+            # cannot be another switch.  If not, it is set to true.
+            if types[switch] == OPTIONAL
+               nextval = ARGV[index+1]
+               if valid.include?(nextval)
+                  hash[switch] = true
+               else
+                  hash[switch] = nextval
+                  ARGV.delete_at(index+1)
+               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
+         hash.each{ |switch, val|
+            if syns.keys.include?(switch)
+               syns[switch].each{ |key|
+                  hash[key] = val   
+               }
+            end
+         }
+
+         # Get rid of leading "--" and "-" to make it easier to reference
+         hash.each{ |key, value|
+            if key[0,2] == '--'
+               nkey = key.sub('--', '')
+            else
+               nkey = key.sub('-', '')
+            end
+            hash.delete(key)
+            hash[nkey] = value
+         }
+
+         hash
+      end
+
+   end
+end

data/lib/thor.rb

@@ -0,0 +1,121 @@
+$:.unshift File.expand_path(File.dirname(__FILE__))
+require "getopt"
+require "thor/util"
+require "thor/task"
+require "thor/task_hash"
+
+class Thor
+  def self.map(map)
+    @map ||= superclass.instance_variable_get("@map") || {}
+    map.each do |key, value|
+      if key.respond_to?(:each)
+        key.each {|subkey| @map[subkey] = value}
+      else
+        @map[key] = value
+      end
+    end
+  end
+
+  def self.desc(usage, description)
+    @usage, @desc = usage, description
+  end
+  
+  def self.method_options(opts)
+    @method_options = opts.inject({}) do |accum, (k,v)|
+      accum.merge("--" + k.to_s => v.to_s.upcase)
+    end
+  end
+
+  def self.subclass_files
+    @subclass_files ||= Hash.new {|h,k| h[k] = []}
+  end
+  
+  def self.subclasses
+    @subclasses ||= []
+  end
+  
+  def self.tasks
+    @tasks ||= TaskHash.new(self)
+  end
+
+  def self.[](task)
+    namespaces = task.split(":")
+    klass = Thor::Util.constant_from_thor_path(namespaces[0...-1].join(":"))
+    raise Error, "`#{klass}' is not a Thor class" unless klass <= Thor
+    klass.tasks[namespaces.last]
+  end
+
+  def self.maxima
+    @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
+      Struct.new(:description, :usage, :opt).new(max_desc, max_usage, max_opts)
+    end
+  end
+  
+  def self.start(args = ARGV)
+    meth = args.first
+    meth = @map[meth].to_s if @map && @map[meth]
+    meth ||= "help"
+    
+    tasks[meth].parse args[1..-1]
+  rescue Thor::Error => e
+    $stderr.puts e.message
+  end
+
+  class << self
+    protected
+    def inherited(klass)
+      register_klass_file klass
+    end
+
+    def method_added(meth)
+      meth = meth.to_s
+      return if !public_instance_methods.include?(meth) || !@usage
+      register_klass_file self
+
+      tasks[meth] = Task.new(meth, @desc, @usage, @method_options)
+
+      @usage, @desc, @method_options = nil
+    end
+
+    def register_klass_file(klass, file = caller[1].split(":")[0])
+      unless self == Thor
+        superclass.register_klass_file(klass, file)
+        return
+      end
+
+      file_subclasses = subclass_files[File.expand_path(file)]
+      file_subclasses << klass unless file_subclasses.include?(klass)
+      subclasses << klass unless subclasses.include?(klass)
+    end
+  end
+  
+  map ["-h", "-?", "--help", "-D"] => :help
+  
+  desc "help [TASK]", "describe available tasks or one specific task"
+  def help(task = nil)
+    if task
+      if task.include? ?:
+        task = self.class[task]
+        namespace = true
+      else
+        task = self.class.tasks[task]
+      end
+
+      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
+    end
+  end
+  
+end

data/lib/thor/error.rb

@@ -0,0 +1,3 @@
+class Thor
+  class Error < Exception; end
+end

data/lib/thor/ordered_hash.rb

@@ -0,0 +1,64 @@
+class Thor
+  # This class is based on the Ruby 1.9 ordered hashes.
+  # It keeps the semantics and most of the efficiency of normal hashes
+  # while also keeping track of the order in which elements were set.
+  class OrderedHash
+    Node = Struct.new(:key, :value, :next, :prev)
+    include Enumerable
+
+    def initialize
+      @hash = {}
+    end
+
+    def initialize_copy(other)
+      @hash = other.instance_variable_get('@hash').clone
+    end
+
+    def [](key)
+      @hash[key] && @hash[key].value
+    end
+
+    def []=(key, value)
+      node = Node.new(key, value)
+
+      if old = @hash[key]
+        if old.prev
+          old.prev.next = old.next
+        else # old is @first and @last
+          @first = @last = nil
+        end
+      end
+
+      if @first.nil?
+        @first = @last = node
+      else
+        node.prev = @last
+        @last.next = node
+        @last = node
+      end
+
+      @hash[key] = node
+      value
+    end
+
+    def each
+      return unless @first
+      yield [@first.key, @first.value]
+      node = @first
+      yield [node.key, node.value] while node = node.next
+      self
+    end
+
+    def values
+      self.map { |k, v| v }
+    end
+
+    def +(other)
+      new = clone
+      other.each do |key, value|
+        new[key] = value unless self[key]
+      end
+      new
+    end
+  end
+end

data/lib/thor/runner.rb

@@ -0,0 +1,222 @@
+require 'thor'
+require "thor/util"
+require "open-uri"
+require "fileutils"
+require "yaml"
+require "digest/md5"
+require "readline"
+
+class Thor::Runner < Thor
+  
+  def self.globs_for(path)
+    ["#{path}/Thorfile", "#{path}/*.thor", "#{path}/tasks/*.thor", "#{path}/lib/tasks/*.thor"]
+  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
+  def install(name, opts = {})
+    initialize_thorfiles
+    begin
+      contents = open(name).read
+    rescue OpenURI::HTTPError
+      raise Error, "Error opening URI `#{name}'"
+    rescue Errno::ENOENT
+      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 unless response =~ /^\s*y/i
+    
+    constants = Thor::Util.constants_in_contents(contents)
+    
+    name = name =~ /\.thor$/ || is_uri ? name : "#{name}.thor"
+    
+    as = opts["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?
+    end
+    
+    FileUtils.mkdir_p thor_root
+    
+    yaml_file = File.join(thor_root, "thor.yml")
+    FileUtils.touch(yaml_file)
+    yaml = thor_yaml
+    
+    yaml[as] = {:filename => Digest::MD5.hexdigest(name + as), :location => name, :constants => constants}
+    
+    save_yaml(yaml)
+    
+    puts "Storing thor file in your system repository"
+    
+    File.open(File.join(thor_root, yaml[as][:filename] + ".thor"), "w") do |file|
+      file.puts contents
+    end
+  end
+  
+  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]}.thor")
+    File.delete(file)
+    yaml.delete(name)
+    save_yaml(yaml)
+    
+    puts "Done."
+  end
+  
+  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]
+
+    puts "Updating `#{name}' from #{yaml[name][:location]}"
+    install(yaml[name][:location], "as" => name)
+  end
+  
+  desc "installed", "list the installed Thor modules and tasks (--internal means list the built-in tasks as well)"
+  method_options :internal => :boolean
+  def installed(opts = {})
+    Dir["#{ENV["HOME"]}/.thor/**/*.thor"].each do |f|
+      load f unless Thor.subclass_files.keys.include?(File.expand_path(f))
+    end
+
+    klasses = Thor.subclasses
+    klasses -= [Thor, Thor::Runner] unless opts['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
+  def list(search = "", options = {})
+    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})
+  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
+  end
+    
+  def method_missing(meth, *args)
+    meth = meth.to_s
+    super(meth.to_sym, *args) unless meth.include? ?:
+
+    initialize_thorfiles(meth)
+    Thor[meth].parse ARGV[1..-1]
+  end
+  
+  private
+  def thor_root
+    File.join(ENV["HOME"], ".thor")
+  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.size <=> yk.size }.first.size
+      
+      print "%-#{max_name + 4}s" % "Modules"
+      puts "Namespaces"
+      print "%-#{max_name + 4}s" % "-------"
+      puts "----------"
+      
+      yaml.each do |name, info|
+        print "%-#{max_name + 4}s" % name
+        puts info[:constants].map {|c| Thor::Util.constant_to_thor_path(c)}.join(", ")
+      end
+    
+      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
+    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
+    end
+  end
+
+  def initialize_thorfiles(relevant_to = nil)
+    thorfiles(relevant_to).each {|f| load f unless Thor.subclass_files.keys.include?(File.expand_path(f))}
+  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 = Dir[*Thor::Runner.globs_for(path)]
+      path = File.dirname(path)
+      break if path == "/"
+    end
+
+    # We want to load system-wide Thorfiles first
+    # so the local Thorfiles will override them.
+    (relevant_to ? thorfiles_relevant_to(relevant_to) :
+     Dir["#{ENV["HOME"]}/.thor/**/*.thor"]) + thorfiles
+  end
+
+  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]}.thor") }
+  end
+
+end

data/lib/thor/task.rb

@@ -0,0 +1,74 @@
+require 'thor/error'
+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 parse(args)
+      run(*parse_args(args))
+    end
+
+    def run(*params)
+      raise Error, "klass is not defined for #{self.inspect}" unless klass
+      raise NoMethodError, "the `#{meth}' task of #{klass} is private" if
+        (klass.private_instance_methods + klass.protected_instance_methods).include?(meth)
+
+      klass.new.send(meth, *params)
+    rescue ArgumentError => e
+      raise e unless e.backtrace.first =~ /:in `#{meth}'$/
+      raise Error, "`#{meth}' was called incorrectly. Call as `#{formatted_usage}'"
+    rescue NoMethodError => e
+      raise e unless e.message =~ /^undefined method `#{meth}' for #<#{klass}:.*>$/
+      raise Error, "The #{namespace false} namespace doesn't have a `#{meth}' task"
+    end
+
+    def namespace(remove_default = true)
+      Thor::Util.constant_to_thor_path(klass, remove_default)
+    end
+
+    def with_klass(klass)
+      new = self.dup
+      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
+        elsif val == "OPTIONAL"
+          "[" + opt + "=" + opt.gsub(/\-/, "").upcase + "]"
+        end
+      end.join(" ")
+    end
+
+    def formatted_usage(namespace = false)
+      (namespace ? self.namespace + ':' : '') + usage +
+        (opts ? " " + formatted_opts : "")
+    end
+
+    protected
+
+    def parse_args(args)
+      return args unless opts
+
+      args = args.dup
+      params = []
+      params << args.shift until args.empty? || args.first[0] == ?-
+
+      old_argv = ARGV.dup
+      ARGV.replace args
+      options = Getopt::Long.getopts(*opts.map do |opt, val|
+        [opt, val == true ? Getopt::BOOLEAN : Getopt.const_get(val)].flatten
+      end)
+      ARGV.replace old_argv
+      params + [options]
+    end
+  end
+end

data/lib/thor/task_hash.rb

@@ -0,0 +1,22 @@
+require 'thor/ordered_hash'
+require 'thor/task'
+
+class Thor::TaskHash < Thor::OrderedHash
+  def initialize(klass)
+    super()
+    @klass = klass
+  end
+
+  def each(local = false, &block)
+    super() { |k, t| yield k, t.with_klass(@klass) }
+    @klass.superclass.tasks.each { |k, t| yield k, t.with_klass(@klass) } unless local || @klass == Thor
+  end
+
+  def [](name)
+    if task = super(name)
+      return task.with_klass(@klass)
+    end
+
+    Thor::Task.dynamic(name, @klass)
+  end
+end

data/lib/thor/tasks.rb

@@ -0,0 +1,70 @@
+require "thor"
+require "fileutils"
+
+class Thor
+  def self.package_task(spec)
+    desc "package", "package up the gem"
+    define_method :package do
+      FileUtils.mkdir_p(File.join(Dir.pwd, "pkg"))
+      Gem::Builder.new(spec).build
+      FileUtils.mv(spec.file_name, File.join(Dir.pwd, "pkg", spec.file_name))
+    end
+  end
+  
+  def self.install_task(spec)
+    package_task spec
+    
+    desc "install", "install the gem"
+    define_method :install do
+      old_stderr, $stderr = $stderr.dup, File.open("/dev/null", "w")
+      package
+      $stderr = old_stderr
+      system %{sudo gem install pkg/#{spec.name}-#{spec.version} --no-rdoc --no-ri --no-update-sources}
+    end
+  end
+  
+  def self.spec_task(file_list, opts = {})
+    name = opts.delete(:name) || "spec"
+    rcov_dir = opts.delete(:rcov_dir) || "coverage"
+    file_list = file_list.map {|f| %["#{f}"]}.join(" ")
+    verbose = opts.delete(:verbose)
+    opts = {:format => "specdoc", :color => true}.merge(opts)
+    
+    rcov_opts = convert_task_options(opts.delete(:rcov) || {})
+    rcov = !rcov_opts.empty?
+    options = convert_task_options(opts)
+    
+    if rcov
+      FileUtils.rm_rf(File.join(Dir.pwd, rcov_dir))
+    end
+    
+    desc(name, "spec task")
+    define_method(name) do
+      cmd = "ruby "
+      if rcov
+        cmd << "-S rcov -o #{rcov_dir} #{rcov_opts} "
+      end
+      cmd << `which spec`.chomp
+      cmd << " -- " if rcov
+      cmd << " "
+      cmd << file_list
+      cmd << " "
+      cmd << options
+      puts cmd if verbose
+      system(cmd)
+    end
+  end
+  
+  private
+  def self.convert_task_options(opts)
+    opts.map do |key, value|
+      if value == true
+        "--#{key}"
+      elsif value.is_a?(Array)
+        value.map {|v| "--#{key} #{v.inspect}"}.join(" ")
+      else
+        "--#{key} #{value.inspect}"
+      end
+    end.join(" ")    
+  end  
+end

data/lib/thor/util.rb

@@ -0,0 +1,43 @@
+require 'thor/error'
+
+class Thor
+  module Util
+    
+    def self.constant_to_thor_path(str, remove_default = true)
+      str = snake_case(str.to_s).squeeze(":")
+      str.gsub!(/^default/, '') if remove_default
+      str
+    end
+
+    def self.constant_from_thor_path(str)
+      make_constant(to_constant(str))
+    rescue NameError => e
+      raise e unless e.message =~ /^uninitialized constant (.*)$/
+      raise Error, "There was no available namespace `#{str}'."
+    end
+
+    def self.to_constant(str)
+      str = 'default' if str.empty?
+      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
+    end
+
+    def self.make_constant(str)
+      list = str.split("::").inject(Object) {|obj, x| obj.const_get(x)}
+    end
+    
+    def self.snake_case(str)
+      return str.downcase if str =~ /^[A-Z_]+$/
+      str.gsub(/\B[A-Z]/, '_\&').squeeze('_') =~ /_*(.*)/
+      return $+.downcase
+    end  
+    
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: wycats-thor
+version: !ruby/object:Gem::Version 
+  version: 0.9.2
+platform: ruby
+authors: 
+- Yehuda Katz
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-05-19 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: A gem that maps options to a class
+email: wycats@gmail.com
+executables: 
+- thor
+- rake2thor
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+- LICENSE
+files: 
+- LICENSE
+- README.markdown
+- Rakefile
+- bin/rake2thor
+- bin/thor
+- lib/getopt.rb
+- lib/thor
+- lib/thor/error.rb
+- lib/thor/ordered_hash.rb
+- lib/thor/runner.rb
+- lib/thor/task.rb
+- lib/thor/task_hash.rb
+- lib/thor/tasks.rb
+- lib/thor/util.rb
+- lib/thor.rb
+has_rdoc: true
+homepage: http://yehudakatz.com
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: thor
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: A gem that maps options to a class
+test_files: []
+