thor 0.9.2 → 0.9.5

data/lib/thor.rb

@@ -1,12 +1,31 @@
 $:.unshift File.expand_path(File.dirname(__FILE__))
-require "getopt"
+require "thor/options"
+require "thor/util"
+require "thor/task"
+require "thor/task_hash"
 
 class Thor
-  def self.inherited(klass)
-    subclass_files[File.expand_path(caller[0].split(":")[0])] << klass
-    subclasses << klass unless subclasses.include?(klass)
+  attr_accessor :options
+  
+  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
+  end
+
   def self.subclass_files
     @subclass_files ||= Hash.new {|h,k| h[k] = []}
   end
@@ -15,117 +34,105 @@ class Thor
     @subclasses ||= []
   end
   
-  def self.method_added(meth)
-    meth = meth.to_s
-    return if !public_instance_methods.include?(meth) || !@usage
-    @descriptions ||= []
-    @usages ||= []
-    @opts ||= []
-
-    @descriptions.delete(@descriptions.assoc(meth))
-    @descriptions << [meth, @desc]
-
-    @usages.delete(@usages.assoc(meth))
-    @usages << [meth, @usage]
-    
-    @opts.delete(@opts.assoc(meth))    
-    @opts << [meth, @method_options] if @method_options
-
-    @usage, @desc, @method_options = nil
+  def self.tasks
+    @tasks ||= TaskHash.new(self)
   end
 
-  def self.map(map)
-    @map ||= superclass.instance_variable_get("@map") || {}
-    @map.merge! map
+  def self.opts
+    (@opts || {}).merge(self == Thor ? {} : superclass.opts)
   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
+  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.help_list
-    return nil unless @usages
-    @help_list ||= begin
-      max_usage = @usages.max {|x,y| x.last.to_s.size <=> y.last.to_s.size}.last.size
-      max_opts  = @opts.empty? ? 0 : format_opts(@opts.max {|x,y| x.last.to_s.size <=> y.last.to_s.size}.last).size 
-      max_desc  = @descriptions.max {|x,y| x.last.to_s.size <=> y.last.to_s.size}.last.size
-      Struct.new(:klass, :usages, :opts, :descriptions, :max).new(
-        self, @usages, @opts, @descriptions, Struct.new(:usage, :opt, :desc).new(max_usage, max_opts, max_desc)
-      )
+  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.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.format_opts(opts)
-    return "" if !opts
-    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 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 new(opts, *args), args[1..-1]
+  rescue Thor::Error => e
+    $stderr.puts e.message
   end
-  
-  def self.start
-    meth = ARGV.shift
-    params = []
-    while !ARGV.empty?
-      break if ARGV.first =~ /^\-/
-      params << ARGV.shift
-    end
-    if defined?(@map) && @map[meth]
-      meth = @map[meth].to_s
+
+  class << self
+    protected
+    def inherited(klass)
+      register_klass_file klass
     end
-    
-    args = ARGV.dup
-    
-    if @opts.assoc(meth)
-      opts = @opts.assoc(meth).last.map {|opt, val| [opt, val == true ? Getopt::BOOLEAN : Getopt.const_get(val)].flatten}
-      options = Getopt::Long.getopts(*opts)
-      params << options
+
+    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
+
+      tasks[meth] = Task.new(meth, @desc, @usage, @method_options)
+
+      @usage, @desc, @method_options = nil
     end
-    
-    ARGV.replace args
-    
-    new(meth, params).instance_variable_get("@results")
-  end
-  
-  def initialize(op, params)
-    begin
-      op ||= "help"
-      @results = send(op.to_sym, *params) if public_methods.include?(op) || !methods.include?(op)
-    rescue ArgumentError
-      puts "`#{op}' was called incorrectly. Call as `#{usage(op)}'"
+
+    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
 
-  public :initialize
-  
-  def usage(meth)
-    list = self.class.help_list
-    list.usages.assoc(meth)[1] + (list.opts.assoc(meth) ? " " + self.class.format_opts(list.opts.assoc(meth)[1]) : "")
+  def initialize(opts = {}, *args)
   end
   
-  map "--help" => :help
+  map ["-h", "-?", "--help", "-D"] => :help
   
-  desc "help", "show this screen"
-  def help
-    list = self.class.help_list
-    puts "Options"
-    puts "-------"
-    list.usages.each do |meth, use|
-      format = "%-" + (list.max.usage + list.max.opt + 4).to_s + "s"
-      print format % ("#{usage(meth)}")
-      puts  list.descriptions.assoc(meth)[1]
+  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
+    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
   
-end
+end

data/lib/thor/error.rb

@@ -0,0 +1,3 @@
+class Thor
+  class Error < Exception; 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