millisami-thor 0.14.6

data/lib/thor/core_ext/ordered_hash.rb

@@ -0,0 +1,100 @@
+class Thor
+  module CoreExt #:nodoc:
+
+    if RUBY_VERSION >= '1.9'
+      class OrderedHash < ::Hash
+      end
+    else
+      # 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 #:nodoc:
+        include Enumerable
+
+        Node = Struct.new(:key, :value, :next, :prev)
+
+        def initialize
+          @hash = {}
+        end
+
+        def [](key)
+          @hash[key] && @hash[key].value
+        end
+
+        def []=(key, value)
+          if node = @hash[key]
+            node.value = value
+          else
+            node = Node.new(key, value)
+
+            if @first.nil?
+              @first = @last = node
+            else
+              node.prev = @last
+              @last.next = node
+              @last = node
+            end
+          end
+
+          @hash[key] = node
+          value
+        end
+
+        def delete(key)
+          if node = @hash[key]
+            prev_node = node.prev
+            next_node = node.next
+
+            next_node.prev = prev_node if next_node
+            prev_node.next = next_node if prev_node
+
+            @first = next_node if @first == node
+            @last = prev_node  if @last  == node
+
+            value = node.value
+          end
+
+          @hash.delete(key)
+          value
+        end
+
+        def keys
+          self.map { |k, v| k }
+        end
+
+        def values
+          self.map { |k, v| v }
+        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 merge(other)
+          hash = self.class.new
+
+          self.each do |key, value|
+            hash[key] = value
+          end
+
+          other.each do |key, value|
+            hash[key] = value
+          end
+
+          hash
+        end
+
+        def empty?
+          @hash.empty?
+        end
+      end
+    end
+
+  end
+end

data/lib/thor/error.rb

@@ -0,0 +1,30 @@
+class Thor
+  # Thor::Error is raised when it's caused by wrong usage of thor classes. Those
+  # errors have their backtrace supressed and are nicely shown to the user.
+  #
+  # Errors that are caused by the developer, like declaring a method which
+  # overwrites a thor keyword, it SHOULD NOT raise a Thor::Error. This way, we
+  # ensure that developer errors are shown with full backtrace.
+  #
+  class Error < StandardError
+  end
+
+  # Raised when a task was not found.
+  #
+  class UndefinedTaskError < Error
+  end
+
+  # Raised when a task was found, but not invoked properly.
+  #
+  class InvocationError < Error
+  end
+
+  class UnknownArgumentError < Error
+  end
+
+  class RequiredArgumentMissingError < InvocationError
+  end
+
+  class MalformattedArgumentError < InvocationError
+  end
+end

data/lib/thor/group.rb

@@ -0,0 +1,276 @@
+require 'thor/base'
+
+# Thor has a special class called Thor::Group. The main difference to Thor class
+# is that it invokes all tasks at once. It also include some methods that allows
+# invocations to be done at the class method, which are not available to Thor
+# tasks.
+class Thor::Group
+  class << self
+    # The description for this Thor::Group. If none is provided, but a source root
+    # exists, tries to find the USAGE one folder above it, otherwise searches
+    # in the superclass.
+    #
+    # ==== Parameters
+    # description<String>:: The description for this Thor::Group.
+    #
+    def desc(description=nil)
+      case description
+        when nil
+          @desc ||= from_superclass(:desc, nil)
+        else
+          @desc = description
+      end
+    end
+
+    # Prints help information.
+    #
+    # ==== Options
+    # short:: When true, shows only usage.
+    #
+    def help(shell)
+      shell.say "Usage:"
+      shell.say "  #{banner}\n"
+      shell.say
+      class_options_help(shell)
+      shell.say self.desc if self.desc
+    end
+
+    # Stores invocations for this class merging with superclass values.
+    #
+    def invocations #:nodoc:
+      @invocations ||= from_superclass(:invocations, {})
+    end
+
+    # Stores invocation blocks used on invoke_from_option.
+    #
+    def invocation_blocks #:nodoc:
+      @invocation_blocks ||= from_superclass(:invocation_blocks, {})
+    end
+
+    # Invoke the given namespace or class given. It adds an instance
+    # method that will invoke the klass and task. You can give a block to
+    # configure how it will be invoked.
+    #
+    # The namespace/class given will have its options showed on the help
+    # usage. Check invoke_from_option for more information.
+    #
+    def invoke(*names, &block)
+      options = names.last.is_a?(Hash) ? names.pop : {}
+      verbose = options.fetch(:verbose, true)
+
+      names.each do |name|
+        invocations[name] = false
+        invocation_blocks[name] = block if block_given?
+
+        class_eval <<-METHOD, __FILE__, __LINE__
+          def _invoke_#{name.to_s.gsub(/\W/, '_')}
+            klass, task = self.class.prepare_for_invocation(nil, #{name.inspect})
+
+            if klass
+              say_status :invoke, #{name.inspect}, #{verbose.inspect}
+              block = self.class.invocation_blocks[#{name.inspect}]
+              _invoke_for_class_method klass, task, &block
+            else
+              say_status :error, %(#{name.inspect} [not found]), :red
+            end
+          end
+        METHOD
+      end
+    end
+
+    # Invoke a thor class based on the value supplied by the user to the
+    # given option named "name". A class option must be created before this
+    # method is invoked for each name given.
+    #
+    # ==== Examples
+    #
+    #   class GemGenerator < Thor::Group
+    #     class_option :test_framework, :type => :string
+    #     invoke_from_option :test_framework
+    #   end
+    #
+    # ==== Boolean options
+    #
+    # In some cases, you want to invoke a thor class if some option is true or
+    # false. This is automatically handled by invoke_from_option. Then the
+    # option name is used to invoke the generator.
+    #
+    # ==== Preparing for invocation
+    #
+    # In some cases you want to customize how a specified hook is going to be
+    # invoked. You can do that by overwriting the class method
+    # prepare_for_invocation. The class method must necessarily return a klass
+    # and an optional task.
+    #
+    # ==== Custom invocations
+    #
+    # You can also supply a block to customize how the option is giong to be
+    # invoked. The block receives two parameters, an instance of the current
+    # class and the klass to be invoked.
+    #
+    def invoke_from_option(*names, &block)
+      options = names.last.is_a?(Hash) ? names.pop : {}
+      verbose = options.fetch(:verbose, :white)
+
+      names.each do |name|
+        unless class_options.key?(name)
+          raise ArgumentError, "You have to define the option #{name.inspect} " <<
+                               "before setting invoke_from_option."
+        end
+
+        invocations[name] = true
+        invocation_blocks[name] = block if block_given?
+
+        class_eval <<-METHOD, __FILE__, __LINE__
+          def _invoke_from_option_#{name.to_s.gsub(/\W/, '_')}
+            return unless options[#{name.inspect}]
+
+            value = options[#{name.inspect}]
+            value = #{name.inspect} if TrueClass === value
+            klass, task = self.class.prepare_for_invocation(#{name.inspect}, value)
+
+            if klass
+              say_status :invoke, value, #{verbose.inspect}
+              block = self.class.invocation_blocks[#{name.inspect}]
+              _invoke_for_class_method klass, task, &block
+            else
+              say_status :error, %(\#{value} [not found]), :red
+            end
+          end
+        METHOD
+      end
+    end
+
+    # Remove a previously added invocation.
+    #
+    # ==== Examples
+    #
+    #   remove_invocation :test_framework
+    #
+    def remove_invocation(*names)
+      names.each do |name|
+        remove_task(name)
+        remove_class_option(name)
+        invocations.delete(name)
+        invocation_blocks.delete(name)
+      end
+    end
+
+    # Overwrite class options help to allow invoked generators options to be
+    # shown recursively when invoking a generator.
+    #
+    def class_options_help(shell, groups={}) #:nodoc:
+      get_options_from_invocations(groups, class_options) do |klass|
+        klass.send(:get_options_from_invocations, groups, class_options)
+      end
+      super(shell, groups)
+    end
+
+    # Get invocations array and merge options from invocations. Those
+    # options are added to group_options hash. Options that already exists
+    # in base_options are not added twice.
+    #
+    def get_options_from_invocations(group_options, base_options) #:nodoc:
+      invocations.each do |name, from_option|
+        value = if from_option
+          option = class_options[name]
+          option.type == :boolean ? name : option.default
+        else
+          name
+        end
+        next unless value
+
+        klass, task = prepare_for_invocation(name, value)
+        next unless klass && klass.respond_to?(:class_options)
+
+        value = value.to_s
+        human_name = value.respond_to?(:classify) ? value.classify : value
+
+        group_options[human_name] ||= []
+        group_options[human_name] += klass.class_options.values.select do |class_option|
+          base_options[class_option.name.to_sym].nil? && class_option.group.nil? &&
+          !group_options.values.flatten.any? { |i| i.name == class_option.name }
+        end
+
+        yield klass if block_given?
+      end
+    end
+
+    # Returns tasks ready to be printed.
+    def printable_tasks(*)
+      item = []
+      item << banner
+      item << (desc ? "# #{desc.gsub(/\s+/m,' ')}" : "")
+      [item]
+    end
+
+    def handle_argument_error(task, error) #:nodoc:
+      raise error, "#{task.name.inspect} was called incorrectly. Are you sure it has arity equals to 0?"
+    end
+
+    protected
+
+      # The method responsible for dispatching given the args.
+      def dispatch(task, given_args, given_opts, config) #:nodoc:
+        if Thor::HELP_MAPPINGS.include?(given_args.first)
+          help(config[:shell])
+          return
+        end
+
+        args, opts = Thor::Options.split(given_args)
+        opts = given_opts || opts
+
+        instance = new(args, opts, config)
+        args = instance.args
+
+        if task
+          instance.invoke_task(all_tasks[task])
+        else
+          instance.invoke_all
+        end
+      end
+
+      # The banner for this class. You can customize it if you are invoking the
+      # thor class by another ways which is not the Thor::Runner.
+      def banner
+        "#{basename} #{self_task.formatted_usage(self, false)}"
+      end
+
+      # Represents the whole class as a task.
+      def self_task #:nodoc:
+        Thor::DynamicTask.new(self.namespace, class_options)
+      end
+
+      def baseclass #:nodoc:
+        Thor::Group
+      end
+
+      def create_task(meth) #:nodoc:
+        tasks[meth.to_s] = Thor::Task.new(meth, nil, nil, nil, nil)
+        true
+      end
+  end
+
+  include Thor::Base
+
+  protected
+
+  # Shortcut to invoke with padding and block handling. Use internally by
+  # invoke and invoke_from_option class methods.
+  def _invoke_for_class_method(klass, task=nil, *args, &block) #:nodoc:
+    with_padding do
+      if block
+        case block.arity
+        when 3
+          block.call(self, klass, task)
+        when 2
+          block.call(self, klass)
+        when 1
+          instance_exec(klass, &block)
+        end
+      else
+        invoke klass, task, *args
+      end
+    end
+  end
+end

data/lib/thor/invocation.rb

@@ -0,0 +1,168 @@
+class Thor
+  module Invocation
+    def self.included(base) #:nodoc:
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      # This method is responsible for receiving a name and find the proper
+      # class and task for it. The key is an optional parameter which is
+      # available only in class methods invocations (i.e. in Thor::Group).
+      def prepare_for_invocation(key, name) #:nodoc:
+        case name
+        when Symbol, String
+          Thor::Util.find_class_and_task_by_namespace(name.to_s, !key)
+        else
+          name
+        end
+      end
+    end
+
+    # Make initializer aware of invocations and the initialization args.
+    def initialize(args=[], options={}, config={}, &block) #:nodoc:
+      @_invocations = config[:invocations] || Hash.new { |h,k| h[k] = [] }
+      @_initializer = [ args, options, config ]
+      super
+    end
+
+    # Receives a name and invokes it. The name can be a string (either "task" or
+    # "namespace:task"), a Thor::Task, a Class or a Thor instance. If the task
+    # cannot be guessed by name, it can also be supplied as second argument.
+    #
+    # You can also supply the arguments, options and configuration values for
+    # the task to be invoked, if none is given, the same values used to
+    # initialize the invoker are used to initialize the invoked.
+    #
+    # When no name is given, it will invoke the default task of the current class.
+    #
+    # ==== Examples
+    #
+    #   class A < Thor
+    #     def foo
+    #       invoke :bar
+    #       invoke "b:hello", ["José"]
+    #     end
+    #
+    #     def bar
+    #       invoke "b:hello", ["José"]
+    #     end
+    #   end
+    #
+    #   class B < Thor
+    #     def hello(name)
+    #       puts "hello #{name}"
+    #     end
+    #   end
+    #
+    # You can notice that the method "foo" above invokes two tasks: "bar",
+    # which belongs to the same class and "hello" which belongs to the class B.
+    #
+    # By using an invocation system you ensure that a task is invoked only once.
+    # In the example above, invoking "foo" will invoke "b:hello" just once, even
+    # if it's invoked later by "bar" method.
+    #
+    # When class A invokes class B, all arguments used on A initialization are
+    # supplied to B. This allows lazy parse of options. Let's suppose you have
+    # some rspec tasks:
+    #
+    #   class Rspec < Thor::Group
+    #     class_option :mock_framework, :type => :string, :default => :rr
+    #
+    #     def invoke_mock_framework
+    #       invoke "rspec:#{options[:mock_framework]}"
+    #     end
+    #   end
+    #
+    # As you noticed, it invokes the given mock framework, which might have its
+    # own options:
+    #
+    #   class Rspec::RR < Thor::Group
+    #     class_option :style, :type => :string, :default => :mock
+    #   end
+    #
+    # Since it's not rspec concern to parse mock framework options, when RR
+    # is invoked all options are parsed again, so RR can extract only the options
+    # that it's going to use.
+    #
+    # If you want Rspec::RR to be initialized with its own set of options, you
+    # have to do that explicitely:
+    #
+    #   invoke "rspec:rr", [], :style => :foo
+    #
+    # Besides giving an instance, you can also give a class to invoke:
+    #
+    #   invoke Rspec::RR, [], :style => :foo
+    #
+    def invoke(name=nil, *args)
+      if name.nil?
+        warn "[Thor] Calling invoke() without argument is deprecated. Please use invoke_all instead.\n#{caller.join("\n")}"
+        return invoke_all
+      end
+
+      args.unshift(nil) if Array === args.first || NilClass === args.first
+      task, args, opts, config = args
+
+      klass, task = _retrieve_class_and_task(name, task)
+      raise "Expected Thor class, got #{klass}" unless klass <= Thor::Base
+
+      args, opts, config = _parse_initialization_options(args, opts, config)
+      klass.send(:dispatch, task, args, opts, config)
+    end
+
+    # Invoke the given task if the given args.
+    def invoke_task(task, *args) #:nodoc:
+      current = @_invocations[self.class]
+
+      unless current.include?(task.name)
+        current << task.name
+        task.run_cmd(self, *args)
+      end
+    end
+
+    # Invoke all tasks for the current instance.
+    def invoke_all #:nodoc:
+      self.class.all_tasks.map { |_, task| invoke_task(task) }
+    end
+
+    # Invokes using shell padding.
+    def invoke_with_padding(*args)
+      with_padding { invoke(*args) }
+    end
+
+    protected
+
+      # Configuration values that are shared between invocations.
+      def _shared_configuration #:nodoc:
+        { :invocations => @_invocations }
+      end
+
+      # This method simply retrieves the class and task to be invoked.
+      # If the name is nil or the given name is a task in the current class,
+      # use the given name and return self as class. Otherwise, call
+      # prepare_for_invocation in the current class.
+      def _retrieve_class_and_task(name, sent_task=nil) #:nodoc:
+        case
+        when name.nil?
+          [self.class, nil]
+        when self.class.all_tasks[name.to_s]
+          [self.class, name.to_s]
+        else
+          klass, task = self.class.prepare_for_invocation(nil, name)
+          [klass, task || sent_task]
+        end
+      end
+
+      # Initialize klass using values stored in the @_initializer.
+      def _parse_initialization_options(args, opts, config) #:nodoc:
+        stored_args, stored_opts, stored_config = @_initializer
+
+        args ||= stored_args.dup
+        opts ||= stored_opts.dup
+
+        config ||= {}
+        config = stored_config.merge(_shared_configuration).merge!(config)
+
+        [ args, opts, config ]
+      end
+  end
+end

data/lib/thor/parser/argument.rb

@@ -0,0 +1,67 @@
+class Thor
+  class Argument #:nodoc:
+    VALID_TYPES = [ :numeric, :hash, :array, :string ]
+
+    attr_reader :name, :description, :required, :type, :default, :banner
+    alias :human_name :name
+
+    def initialize(name, description=nil, required=true, type=:string, default=nil, banner=nil)
+      class_name = self.class.name.split("::").last
+
+      raise ArgumentError, "#{class_name} name can't be nil."                         if name.nil?
+      raise ArgumentError, "Type :#{type} is not valid for #{class_name.downcase}s."  if type && !valid_type?(type)
+
+      @name        = name.to_s
+      @description = description
+      @required    = required || false
+      @type        = (type || :string).to_sym
+      @default     = default
+      @banner      = banner || default_banner
+
+      validate! # Trigger specific validations
+    end
+
+    def usage
+      required? ? banner : "[#{banner}]"
+    end
+
+    def required?
+      required
+    end
+
+    def show_default?
+      case default
+      when Array, String, Hash
+        !default.empty?
+      else
+        default
+      end
+    end
+
+    protected
+
+      def validate!
+        raise ArgumentError, "An argument cannot be required and have default value." if required? && !default.nil?
+      end
+
+      def valid_type?(type)
+        self.class::VALID_TYPES.include?(type.to_sym)
+      end
+
+      def default_banner
+        case type
+        when :boolean
+          nil
+        when :string, :default
+          human_name.upcase
+        when :numeric
+          "N"
+        when :hash
+          "key:value"
+        when :array
+          "one two three"
+        end
+      end
+
+  end
+end