wycats-thor 0.9.8 → 0.10.26

data/lib/thor.rb

@@ -1,146 +1,234 @@
 $:.unshift File.expand_path(File.dirname(__FILE__))
-require "thor/options"
-require "thor/util"
-require "thor/task"
-require "thor/task_hash"
+require 'thor/base'
+require 'thor/group'
+require 'thor/actions'
 
 class Thor
-  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}
+
+  class << self
+
+    # Sets the default task when thor is executed without an explicit task to be called.
+    #
+    # ==== Parameters
+    # meth<Symbol>:: name of the defaut task
+    #
+    def default_task(meth=nil)
+      case meth
+        when :none
+          @default_task = 'help'
+        when nil
+          @default_task ||= from_superclass(:default_task, 'help')
+        else
+          @default_task = meth.to_s
+      end
+    end
+
+    # Defines the usage and the description of the next task.
+    #
+    # ==== Parameters
+    # usage<String>
+    # description<String>
+    #
+    def desc(usage, description, options={})
+      if options[:for]
+        task = find_and_refresh_task(options[:for])
+        task.usage = usage             if usage
+        task.description = description if description
       else
-        @map[key] = value
+        @usage, @desc = usage, description
       end
     end
-  end
 
-  def self.desc(usage, description)
-    @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
-  end
+    # Maps an input to a task. If you define:
+    #
+    #   map "-T" => "list"
+    #
+    # Running:
+    #
+    #   thor -T
+    #
+    # Will invoke the list task.
+    #
+    # ==== Parameters
+    # Hash[String|Array => Symbol]:: Maps the string or the strings in the array to the given task.
+    #
+    def map(mappings=nil)
+      @map ||= from_superclass(:map, {})
+
+      if mappings
+        mappings.each do |key, value|
+          if key.respond_to?(:each)
+            key.each {|subkey| @map[subkey] = value}
+          else
+            @map[key] = value
+          end
+        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
+      @map
+    end
 
-  def self.opts
-    (@opts || {}).merge(self == Thor ? {} : superclass.opts)
-  end
+    # Declares the options for the next task to be declared.
+    #
+    # ==== Parameters
+    # Hash[Symbol => Object]:: The hash key is the name of the option and the value
+    # is the type of the option. Can be :string, :array, :hash, :boolean, :numeric
+    # or :required (string). If you give a value, the type of the value is used.
+    #
+    def method_options(options=nil)
+      @method_options ||= {}
+      build_options(options, @method_options) if options
+      @method_options
+    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
+    # Adds an option to the set of class options. If :for is given as option,
+    # it allows you to change the options from a previous defined task.
+    #
+    #   def previous_task
+    #     # magic
+    #   end
+    #
+    #   method_options :foo => :bar, :for => :previous_task
+    #
+    #   def next_task
+    #     # magic
+    #   end
+    #
+    # ==== Parameters
+    # name<Symbol>:: The name of the argument.
+    # options<Hash>:: Described below.
+    #
+    # ==== Options
+    # :desc     - Description for the argument.
+    # :required - If the argument is required or not.
+    # :default  - Default value for this argument. It cannot be required and have default values.
+    # :aliases  - Aliases for this option.
+    # :type     - The type of the argument, can be :string, :hash, :array, :numeric, :boolean or :default.
+    #             Default accepts arguments as booleans (--switch) or as strings (--switch=VALUE).
+    # :group    - The group for this options. Use by class options to output options in different levels.
+    # :banner   - String to show on usage notes.
+    #
+    def method_option(name, options)
+      scope = if options[:for]
+        find_and_refresh_task(options[:for]).options
+      else
+        method_options
+      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.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)
+      build_option(name, options, scope)
     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 new(opts, *args), args[1..-1]
-  rescue Thor::Error => e
-    $stderr.puts e.message
-  end
 
-  class << self
-    protected
-    def inherited(klass)
-      register_klass_file klass
+    # Parses the task and options from the given args, instantiate the class
+    # and invoke the task. This method is used when the arguments must be parsed
+    # from an array. If you are inside Ruby and want to use a Thor class, you
+    # can simply initialize it:
+    #
+    #   script = MyScript.new(args, options, config)
+    #   script.invoke(:task, first_arg, second_arg, third_arg)
+    #
+    def start(given_args=ARGV, config={})
+      super do
+        meth = normalize_task_name(given_args.shift)
+        task = all_tasks[meth]
+
+        if task
+          args, opts = Thor::Options.split(given_args)
+          config.merge!(:task_options => task.options)
+        else
+          args, opts = given_args, {}
+        end
+
+        task ||= Task.dynamic(meth)
+        trailing = args[Range.new(arguments.size, -1)]
+        new(args, opts, config).invoke(task, trailing || [])
+      end
     end
 
-    def method_added(meth)
-      meth = meth.to_s
-      
-      if meth == "initialize"
-        @opts = @method_options
-        @method_options = nil
-        return
+    # Prints help information. If a task name is given, it shows information
+    # only about the specific task.
+    #
+    # ==== Parameters
+    # meth<String>:: An optional task name to print usage information about.
+    #
+    # ==== Options
+    # namespace:: When true, shows the namespace in the output before the usage.
+    # skip_inherited:: When true, does not show tasks from superclass.
+    #
+    def help(shell, meth=nil, options={})
+      meth, options = nil, meth if meth.is_a?(Hash)
+
+      if meth
+        task = all_tasks[meth]
+        raise UndefinedTaskError, "task '#{meth}' could not be found in namespace '#{self.namespace}'" unless task
+
+        shell.say "Usage:"
+        shell.say "  #{banner(task, options[:namespace])}"
+        shell.say
+        class_options_help(shell, "Class")
+        shell.say task.description
+      else
+        list = (options[:short] ? tasks : all_tasks).map do |_, task|
+          [ banner(task, options[:namespace]), task.short_description || '' ]
+        end
+
+        if options[:short]
+          shell.print_table(list, :emphasize_last => true)
+        else
+          shell.say "Tasks:"
+          shell.print_table(list, :ident => 2, :emphasize_last => true)
+          shell.say
+
+          class_options_help(shell, "Class")
+        end
       end
+    end
 
-      return if !public_instance_methods.include?(meth) || !@usage
-      register_klass_file self
+    protected
 
-      tasks[meth] = Task.new(meth, @desc, @usage, @method_options)
+      # The banner for this class. You can customize it if you are invoking the
+      # thor class by another means which is not the Thor::Runner. It receives
+      # the task that is going to be invoked and if the namespace should be
+      # displayed.
+      #
+      def banner(task, namespace=true) #:nodoc:
+        task.formatted_usage(self, namespace)
+      end
 
-      @usage, @desc, @method_options = nil
-    end
+      def baseclass #:nodoc:
+        Thor
+      end
 
-    def register_klass_file(klass, file = caller[1].split(":")[0])
-      unless self == Thor
-        superclass.register_klass_file(klass, file)
-        return
+      def valid_task?(meth) #:nodoc:
+        @usage && @desc
       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
+      def create_task(meth) #:nodoc:
+        tasks[meth.to_s] = Thor::Task.new(meth, @desc, @usage, method_options)
+        @usage, @desc, @method_options = nil
+      end
 
-  def initialize(opts = {}, *args)
-  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]
+      def initialize_added #:nodoc:
+        class_options.merge!(method_options)
+        @method_options = nil
       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
+      # Receives a task name (can be nil), and try to get a map from it.
+      # If a map can't be found use the sent name or the default task.
+      #
+      def normalize_task_name(meth) #:nodoc:
+        mapping = map[meth.to_s]
+        meth = mapping || meth || default_task
+        meth.to_s.gsub('-','_') # treat foo-bar > foo_bar
       end
-    end
+
+  end
+
+  include Thor::Base
+
+  map HELP_MAPPINGS => :help
+
+  desc "help [TASK]", "Describe available tasks or one specific task"
+  def help(task=nil)
+    self.class.help(shell, task, :namespace => task && task.include?(?:))
   end
-  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: wycats-thor
 version: !ruby/object:Gem::Version 
-  version: 0.9.8
+  version: 0.10.26
 platform: ruby
 authors: 
 - Yehuda Katz
@@ -9,11 +9,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-27 00:00:00 -07:00
+date: 2009-07-04 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
-description: A gem that maps options to a class
+description: A scripting framework that replaces rake, sake and rubigen
 email: wycats@gmail.com
 executables: 
 - thor
@@ -22,8 +22,8 @@ extensions: []
 
 extra_rdoc_files: 
 - README.markdown
-- CHANGELOG.rdoc
 - LICENSE
+- CHANGELOG.rdoc
 files: 
 - README.markdown
 - LICENSE
@@ -31,18 +31,43 @@ files:
 - Rakefile
 - bin/rake2thor
 - bin/thor
+- lib/thor.rb
 - lib/thor
 - lib/thor/error.rb
-- lib/thor/options.rb
-- lib/thor/ordered_hash.rb
+- lib/thor/base.rb
+- lib/thor/group.rb
+- lib/thor/actions
+- lib/thor/actions/templater.rb
+- lib/thor/actions/copy_file.rb
+- lib/thor/actions/inject_into_file.rb
+- lib/thor/actions/directory.rb
+- lib/thor/actions/template.rb
+- lib/thor/actions/get.rb
+- lib/thor/actions/create_file.rb
+- lib/thor/actions/empty_directory.rb
+- lib/thor/util.rb
 - lib/thor/runner.rb
-- lib/thor/task.rb
-- lib/thor/task_hash.rb
+- lib/thor/actions.rb
+- lib/thor/parser.rb
+- lib/thor/shell
+- lib/thor/shell/basic.rb
+- lib/thor/shell/color.rb
+- lib/thor/invocation.rb
+- lib/thor/parser
+- lib/thor/parser/argument.rb
+- lib/thor/parser/option.rb
+- lib/thor/parser/options.rb
+- lib/thor/parser/arguments.rb
+- lib/thor/tasks.rb
+- lib/thor/core_ext
+- lib/thor/core_ext/hash_with_indifferent_access.rb
+- lib/thor/core_ext/ordered_hash.rb
 - lib/thor/tasks
+- lib/thor/tasks/install.rb
+- lib/thor/tasks/spec.rb
 - lib/thor/tasks/package.rb
-- lib/thor/tasks.rb
-- lib/thor/util.rb
-- lib/thor.rb
+- lib/thor/shell.rb
+- lib/thor/task.rb
 has_rdoc: true
 homepage: http://yehudakatz.com
 post_install_message: 
@@ -67,7 +92,7 @@ requirements: []
 rubyforge_project: thor
 rubygems_version: 1.2.0
 signing_key: 
-specification_version: 2
-summary: A gem that maps options to a class
+specification_version: 3
+summary: A scripting framework that replaces rake, sake and rubigen
 test_files: []
 

data/lib/thor/options.rb

@@ -1,242 +0,0 @@
-# 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 = {}
-      
-      @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 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 undasherize(opt).gsub(/\-/, "_").upcase
-            when :numeric  then "N"
-            end
-          "[" + opt + "=" + sample.to_s + "]"
-        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 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