wycats-thor 0.9.2 → 0.9.5

data/CHANGELOG.rdoc

@@ -0,0 +1,35 @@
+== 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.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

@@ -4,56 +4,73 @@ thor
 Map options to a class. Simply create a class with the appropriate annotations, and have options automatically map
 to functions and parameters.
 
-Examples:
+Example:
 
-    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]
+    class MyApp < Thor                                                # [1]
+      map "-L" => :list                                               # [2]
+                                                                    
+      desc "install APP_NAME", "install one of the available apps"    # [3]
+      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)
-  
-[1] Inherit from Thor to turn a class into an option mapper
+    MyApp.new.install("myname")
+    # with {'force' => true} as options hash
 
-[2] Map additional non-valid identifiers to specific methods. In this case,
+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,
+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>: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>
+  <dt><code>:boolean</code></dt>
+    <dd>true if the option is passed</dd>
+  <dt><code>true</code></dt>
+    <dd>same as <code>:boolean</code></dd>
+  <dt><code>:required</code></dt>
+    <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><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

@@ -1,10 +1,12 @@
 $:.unshift File.expand_path(File.dirname(__FILE__))
-require "getopt"
+require "thor/options"
 require "thor/util"
 require "thor/task"
 require "thor/task_hash"
 
 class Thor
+  attr_accessor :options
+  
   def self.map(map)
     @map ||= superclass.instance_variable_get("@map") || {}
     map.each do |key, value|
@@ -21,9 +23,7 @@ class Thor
   end
   
   def self.method_options(opts)
-    @method_options = opts.inject({}) do |accum, (k,v)|
-      accum.merge("--" + k.to_s => v.to_s.upcase)
-    end
+    @method_options = opts
   end
 
   def self.subclass_files
@@ -38,6 +38,10 @@ class Thor
     @tasks ||= TaskHash.new(self)
   end
 
+  def self.opts
+    (@opts || {}).merge(self == Thor ? {} : superclass.opts)
+  end
+
   def self.[](task)
     namespaces = task.split(":")
     klass = Thor::Util.constant_from_thor_path(namespaces[0...-1].join(":"))
@@ -49,17 +53,21 @@ 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(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"
     
-    tasks[meth].parse args[1..-1]
+    tasks[meth].parse new(opts, *args), args[1..-1]
   rescue Thor::Error => e
     $stderr.puts e.message
   end
@@ -72,6 +80,13 @@ class Thor
 
     def method_added(meth)
       meth = meth.to_s
+
+      if meth == "initialize"
+        @opts = @method_options
+        @method_options = nil
+        return
+      end
+
       return if !public_instance_methods.include?(meth) || !@usage
       register_klass_file self
 
@@ -91,6 +106,9 @@ class Thor
       subclasses << klass unless subclasses.include?(klass)
     end
   end
+
+  def initialize(opts = {}, *args)
+  end
   
   map ["-h", "-?", "--help", "-D"] => :help
   
@@ -106,15 +124,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|
+        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/options.rb

@@ -0,0 +1,238 @@
+# This is a modified version of Daniel Berger's Getopt::Long class,
+# licensed under Ruby's license.
+
+class Thor
+  class Options
+    class Error < StandardError; end
+    
+    # simple Hash with indifferent access
+    class Hash < ::Hash
+      def initialize(hash)
+        super()
+        update hash
+      end
+      
+      def [](key)
+        super convert_key(key)
+      end
+      
+      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.to_s =~ /^(\w+)\?$/ ? !!self[$1] : super
+        end
+    end
+
+    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
+    # 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 = Thor::Options.new(
+    #      "--debug" => true,
+    #      ["--verbose", "-v"] => true,
+    #      ["--level", "-l"] => :numeric
+    #   ).parse(args)
+    #
+    def initialize(switches)
+      @defaults = {}
+      @shorts = {}
+
+      @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 then 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
+
+    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
+          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)
+        nice_name = undasherize(switch)
+        type      = switch_type(switch)
+        
+        case type
+        when :required
+          assert_value!(switch)
+          raise Error, "cannot pass switch '#{peek}' as an argument" if valid?(peek)
+          hash[nice_name] = shift
+        when :optional
+          hash[nice_name] = peek.nil? || valid?(peek) || shift
+        when :boolean
+          hash[nice_name] = true
+        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
+
+      check_required! hash
+      hash.freeze
+      hash
+    end
+    
+    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 opt.gsub(/\-/, "").upcase
+            when :numeric  then "N"
+            end
+          "[" + opt + "=" + sample.to_s + "]"
+        end
+      end.join(" ")
+    end
+
+    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 shift
+      @args.shift
+    end
+
+    def unshift(arg)
+      unless arg.kind_of?(Array)
+        @args.unshift(arg)
+      else
+        @args = arg + @args
+      end
+    end
+    
+    def valid?(arg)
+      @switches.key?(arg) or @shorts.key?(arg)
+    end
+
+    def current_is_option?
+      case peek
+      when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM
+        valid?($1)
+      when SHORT_SQ_RE
+        $1.split('').any? { |f| valid?("-#{f}") }
+      end
+    end
+    
+    def normalize_switch(switch)
+      @shorts.key?(switch) ? @shorts[switch] : switch
+    end
+    
+    def switch_type(switch)
+      @switches[switch]
+    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

@@ -15,8 +15,8 @@ class Thor::Runner < Thor
   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 = {})
+  method_options :as => :optional, :relative => :boolean
+  def install(name)
     initialize_thorfiles
     begin
       contents = open(name).read
@@ -33,13 +33,13 @@ class Thor::Runner < Thor
     print "Do you wish to continue [y/N]? "
     response = Readline.readline
     
-    return unless response =~ /^\s*y/i
+    return false unless response =~ /^\s*y/i
     
     constants = Thor::Util.constants_in_contents(contents)
     
-    name = name =~ /\.thor$/ || is_uri ? name : "#{name}.thor"
+    # name = name =~ /\.thor$/ || is_uri ? name : "#{name}.thor"
     
-    as = opts["as"] || begin
+    as = options["as"] || begin
       first_line = contents.split("\n")[0]
       (match = first_line.match(/\s*#\s*module:\s*([^\n]*)/)) ? match[1].strip : nil
     end
@@ -56,15 +56,18 @@ class Thor::Runner < Thor
     FileUtils.touch(yaml_file)
     yaml = thor_yaml
     
-    yaml[as] = {:filename => Digest::MD5.hexdigest(name + as), :location => name, :constants => constants}
+    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] + ".thor"), "w") do |file|
+    File.open(File.join(thor_root, yaml[as][:filename]), "w") do |file|
       file.puts contents
     end
+    
+    yaml[as][:filename] # Indicate sucess
   end
   
   desc "uninstall NAME", "uninstall a named Thor module"
@@ -74,7 +77,7 @@ class Thor::Runner < Thor
     
     puts "Uninstalling #{name}."
     
-    file = File.join(thor_root, "#{yaml[name][:filename]}.thor")
+    file = File.join(thor_root, "#{yaml[name][:filename]}")
     File.delete(file)
     yaml.delete(name)
     save_yaml(yaml)
@@ -88,24 +91,30 @@ class Thor::Runner < Thor
     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)
+    old_filename = yaml[name][:filename]
+    options["as"] = name
+    filename = install(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)"
   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))
+  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
 
     klasses = Thor.subclasses
-    klasses -= [Thor, Thor::Runner] unless opts['internal']
+    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
-  def list(search = "", options = {})
+  def list(search = "")
     initialize_thorfiles
     search = ".*#{search}" if options["substring"]
     search = /^#{search}.*/i
@@ -125,12 +134,30 @@ class Thor::Runner < Thor
     super(meth.to_sym, *args) unless meth.include? ?:
 
     initialize_thorfiles(meth)
-    Thor[meth].parse ARGV[1..-1]
+    task = Thor[meth]
+    task.parse task.klass.new, ARGV[1..-1]
+  end
+
+  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.
+    Dir["#{thor_root.gsub(/\\/, '/')}/**/*"]
   end
   
   private
   def thor_root
-    File.join(ENV["HOME"], ".thor")
+    self.class.thor_root
+  end
+
+  def thor_root_glob
+    self.class.thor_root_glob
   end
   
   def thor_yaml
@@ -150,14 +177,17 @@ class Thor::Runner < Thor
     
     if with_modules && !(yaml = thor_yaml).empty?
       max_name = yaml.max {|(xk,xv),(yk,yv)| xk.size <=> yk.size }.first.size
+      modules_label = "Modules"
+      namespaces_label = "Namespaces"
+      column_width = [max_name + 4, modules_label.size + 1].max
       
-      print "%-#{max_name + 4}s" % "Modules"
-      puts "Namespaces"
-      print "%-#{max_name + 4}s" % "-------"
-      puts "----------"
+      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 "%-#{max_name + 4}s" % name
+        print "%-#{column_width}s" % name
         puts info[:constants].map {|c| Thor::Util.constant_to_thor_path(c)}.join(", ")
       end
     
@@ -192,7 +222,15 @@ class Thor::Runner < Thor
   end
 
   def initialize_thorfiles(relevant_to = nil)
-    thorfiles(relevant_to).each {|f| load f unless Thor.subclass_files.keys.include?(File.expand_path(f))}
+    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}"
+    end
   end
   
   def thorfiles(relevant_to = nil)
@@ -201,7 +239,7 @@ class Thor::Runner < Thor
     
     # 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)]
+      thorfiles = Thor::Runner.globs_for(path).map {|g| Dir[g]}.flatten
       path = File.dirname(path)
       break if path == "/"
     end
@@ -209,14 +247,14 @@ 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["#{ENV["HOME"]}/.thor/**/*.thor"]) + thorfiles
+     thor_root_glob) + thorfiles - ["#{thor_root}/thor.yml"]
   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.map { |k, v| File.join(thor_root, "#{v[:filename]}") }
   end
 
 end

data/lib/thor/task.rb

@@ -7,21 +7,32 @@ class Thor
       new(meth, "A dynamically-generated task", meth.to_s, nil, klass)
     end
 
-    def parse(args)
-      run(*parse_args(args))
+    def parse(obj, args)
+      list, hash = parse_args(args)
+      obj.options = hash
+      run(obj, *list)
     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)
+    def run(obj, *params)
+      raise NoMethodError, "the `#{meth}' task of #{obj.class} is private" if
+        (obj.private_methods + obj.protected_methods).include?(meth)
+      
+      obj.send(meth, *params)
     rescue ArgumentError => e
-      raise e unless e.backtrace.first =~ /:in `#{meth}'$/
+      # backtrace sans anything in this file
+      backtrace = e.backtrace.reject {|frame| frame =~ /^#{Regexp.escape(__FILE__)}/}
+      # 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
-      raise e unless e.message =~ /^undefined method `#{meth}' for #<#{klass}:.*>$/
+      begin
+        raise e unless e.message =~ /^undefined method `#{meth}' for #{Regexp.escape(obj.inspect)}$/
+      rescue
+        raise e
+      end
       raise Error, "The #{namespace false} namespace doesn't have a `#{meth}' task"
     end
 
@@ -34,41 +45,24 @@ 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
-        elsif val == "OPTIONAL"
-          "[" + opt + "=" + opt.gsub(/\-/, "").upcase + "]"
-        end
-      end.join(" ")
+    
+    def opts
+      return super unless super.kind_of? Hash
+      self.opts = Options.new(super)
     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
-
-      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]
+      return [args, {}] unless opts
+      hash = opts.parse(args)
+      list = opts.non_opts
+      [list, hash]
     end
   end
 end

data/lib/thor/task_hash.rb

@@ -13,7 +13,7 @@ class Thor::TaskHash < Thor::OrderedHash
   end
 
   def [](name)
-    if task = super(name)
+    if task = super(name) || (@klass == Thor && @klass.superclass.tasks[name])
       return task.with_klass(@klass)
     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} install pkg/#{spec.name}-#{spec.version} --no-rdoc --no-ri --no-update-sources}
     end
   end
   
@@ -52,16 +55,20 @@ class Thor
       cmd << options
       puts cmd if verbose
       system(cmd)
+      exit($?.exitstatus)
     end
   end
   
   private
   def self.convert_task_options(opts)
     opts.map do |key, value|
-      if value == true
+      case value
+      when true
         "--#{key}"
-      elsif value.is_a?(Array)
+      when Array
         value.map {|v| "--#{key} #{v.inspect}"}.join(" ")
+      when nil, false
+        ""
       else
         "--#{key} #{value.inspect}"
       end

data/lib/thor/tasks/package.rb

@@ -0,0 +1,18 @@
+require "thor/task"
+
+class Thor::PackageTask < Thor::Task
+  attr_accessor :spec
+  attr_accessor :opts
+
+  def initialize(gemspec, opts = {})
+    super(:package, "build a gem package")
+    @spec = gemspec
+    @opts = {:dir => File.join(Dir.pwd, "pkg")}.merge(opts)
+  end
+
+  def run
+    FileUtils.mkdir_p(@opts[:dir])
+    Gem::Builder.new(spec).build
+    FileUtils.mv(spec.file_name, File.join(@opts[:dir], spec.file_name))
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: wycats-thor
 version: !ruby/object:Gem::Version 
-  version: 0.9.2
+  version: 0.9.5
 platform: ruby
 authors: 
 - Yehuda Katz
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-05-19 00:00:00 -07:00
+date: 2008-08-27 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -22,20 +22,24 @@ extensions: []
 
 extra_rdoc_files: 
 - README.markdown
+- CHANGELOG.rdoc
 - LICENSE
 files: 
-- LICENSE
 - README.markdown
+- LICENSE
+- CHANGELOG.rdoc
 - Rakefile
 - bin/rake2thor
 - bin/thor
-- lib/getopt.rb
 - lib/thor
 - lib/thor/error.rb
+- lib/thor/options.rb
 - lib/thor/ordered_hash.rb
 - lib/thor/runner.rb
 - lib/thor/task.rb
 - lib/thor/task_hash.rb
+- lib/thor/tasks
+- lib/thor/tasks/package.rb
 - lib/thor/tasks.rb
 - lib/thor/util.rb
 - lib/thor.rb
@@ -61,7 +65,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: thor
-rubygems_version: 1.0.1
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: A gem that maps options to a class

data/lib/getopt.rb

@@ -1,238 +0,0 @@
-# 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