wycats-thor 0.9.8 → 0.10.26

data/lib/thor/core_ext/hash_with_indifferent_access.rb

@@ -0,0 +1,75 @@
+class Thor
+  module CoreExt
+
+    # A hash with indifferent access and magic predicates.
+    #
+    #   hash = Thor::CoreExt::HashWithIndifferentAccess.new 'foo' => 'bar', 'baz' => 'bee', 'force' => true
+    #
+    #   hash[:foo]  #=> 'bar'
+    #   hash['foo'] #=> 'bar'
+    #   hash.foo?   #=> true
+    #
+    class HashWithIndifferentAccess < ::Hash
+
+      def initialize(hash={})
+        super()
+        hash.each do |key, value|
+          self[convert_key(key)] = value
+        end
+      end
+
+      def [](key)
+        super(convert_key(key))
+      end
+
+      def []=(key, value)
+        super(convert_key(key), value)
+      end
+
+      def delete(key)
+        super(convert_key(key))
+      end
+
+      def values_at(*indices)
+        indices.collect { |key| self[convert_key(key)] }
+      end
+
+      def merge(other)
+        dup.merge!(other)
+      end
+
+      def merge!(other)
+        other.each do |key, value|
+          self[convert_key(key)] = value
+        end
+        self
+      end
+
+      protected
+
+        def convert_key(key)
+          key.is_a?(Symbol) ? key.to_s : key
+        end
+
+        # Magic predicates. For instance:
+        #
+        #   options.force?                  # => !!options['force']
+        #   options.shebang                 # => "/usr/lib/local/ruby"
+        #   options.test_framework?(:rspec) # => options[:test_framework] == :rspec
+        #
+        def method_missing(method, *args, &block)
+          method = method.to_s
+          if method =~ /^(\w+)\?$/
+            if args.empty?
+              !!self[$1]
+            else
+              self[$1] == args.first
+            end
+          else 
+            self[method]
+          end
+        end
+
+    end
+  end
+end

data/lib/thor/core_ext/ordered_hash.rb

@@ -0,0 +1,102 @@
+require 'forwardable'
+
+class Thor #:nodoc:
+  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

@@ -1,3 +1,27 @@
 class Thor
-  class Error < Exception; end
+  # Thor::Error is raised when it's caused by the user invoking the task and
+  # only errors that inherit from it are rescued.
+  #
+  # So, for example, if the developer declares a required argument after an
+  # option, it should raise an ::ArgumentError and not ::Thor::ArgumentError,
+  # because it was caused by the developer and not the "final user".
+  #
+  class Error < StandardError #:nodoc:
+  end
+
+  # Raised when a task was not found.
+  #
+  class UndefinedTaskError < Error #:nodoc:
+  end
+
+  # Raised when a task was found, but not invoked properly.
+  #
+  class InvocationError < Error #:nodoc:
+  end
+
+  class RequiredArgumentMissingError < InvocationError #:nodoc:
+  end
+
+  class MalformattedArgumentError < InvocationError #:nodoc:
+  end
 end

data/lib/thor/group.rb

@@ -0,0 +1,72 @@
+class Thor::Group
+
+  class << self
+
+    # The descrition 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
+
+    # Start works differently in Thor::Group, it simply invokes all tasks
+    # inside the class.
+    #
+    def start(given_args=ARGV, config={})
+      super do
+        if Thor::HELP_MAPPINGS.include?(given_args.first)
+          help(config[:shell])
+          return
+        end
+
+        args, opts = Thor::Options.split(given_args)
+        new(args, opts, config).invoke
+      end
+    end
+
+    # Prints help information.
+    #
+    # ==== Options
+    # short:: When true, shows only usage.
+    #
+    def help(shell, options={})
+      if options[:short]
+        shell.say banner
+      else
+        shell.say "Usage:"
+        shell.say "  #{banner}"
+        shell.say
+        class_options_help(shell)
+        shell.say self.desc if self.desc
+      end
+    end
+
+    protected
+
+      # 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.
+      #
+      def banner #:nodoc:
+        "#{self.namespace} #{self.arguments.map {|a| a.usage }.join(' ')}"
+      end
+
+      def baseclass #:nodoc:
+        Thor::Group
+      end
+
+      def create_task(meth) #:nodoc:
+        tasks[meth.to_s] = Thor::Task.new(meth, nil, nil, nil)
+      end
+  end
+
+  include Thor::Base
+end

data/lib/thor/invocation.rb

@@ -0,0 +1,161 @@
+class Thor
+  module Invocation
+
+    # Make initializer aware of invocations and the initializer proc.
+    #
+    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.
+    #
+    # ==== 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, task=nil, args=nil, opts=nil, config=nil)
+      task, args, opts, config = nil, task, args, opts if task.nil? || task.is_a?(Array)
+      args, opts, config = nil, args, opts if args.is_a?(Hash)
+
+      object, task = _setup_for_invoke(name, task)
+      if object.is_a?(Class)
+        klass = object
+
+        stored_args, stored_opts, stored_config = @_initializer
+        args ||= stored_args.dup
+        opts ||= stored_opts.dup
+
+        config ||= {}
+        config = stored_config.merge(_shared_configuration).merge!(config)
+        instance = klass.new(args, opts, config)
+      else
+        klass, instance = object.class, object
+      end
+
+      method_args = []
+      current = @_invocations[klass]
+
+      iterator = proc do |_, task|
+        unless current.include?(task.name)
+          current << task.name
+          task.run(instance, method_args)
+        end
+      end
+
+      if task
+        args ||= []
+        method_args = args[Range.new(klass.arguments.size, -1)] || []
+        iterator.call(nil, task)
+      else
+        klass.all_tasks.map(&iterator)
+      end
+    end
+
+    protected
+
+      # Configuration values that are shared between invocations.
+      #
+      def _shared_configuration
+        { :invocations => @_invocations }
+      end
+
+      # This is the method responsable for retrieving and setting up an
+      # instance to be used in invoke.
+      #
+      def _setup_for_invoke(name, sent_task=nil) #:nodoc:
+        case name
+          when Thor::Task
+            task = name
+          when Symbol, String
+            name = name.to_s
+
+            # If is not one of this class tasks, do a lookup.
+            unless task = self.class.all_tasks[name]
+              object, task = Thor::Util.namespace_to_thor_class(name, false)
+              task ||= sent_task
+            end
+          else
+            object, task = name, sent_task
+        end
+
+        # If the object was not set, use self and use the name as task.
+        object, task = self, name unless object
+        return object, _validate_klass_and_task(object, task)
+      end
+
+      # Check if the object given is a Thor class object and get a task object
+      # for it.
+      #
+      def _validate_klass_and_task(object, task)
+        klass = object.is_a?(Class) ? object : object.class
+        raise "Expected Thor class, got #{klass}" unless klass <= Thor::Base
+
+        task ||= klass.default_task if klass <= Thor
+        task = klass.all_tasks[task.to_s] || Task.dynamic(task) if task && !task.is_a?(Thor::Task)
+        task
+      end
+
+  end
+end

data/lib/thor/parser/argument.rb

@@ -0,0 +1,67 @@
+class Thor
+  class Argument
+    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)
+        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