josevalim-thor 0.10.0

data/lib/thor/core_ext/hash_with_indifferent_access.rb

@@ -0,0 +1,59 @@
+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|
+          if key.is_a?(Symbol)
+            self[key.to_s] = value
+          else
+            self[key] = value
+          end
+        end
+      end
+
+      def [](key)
+        super(convert_key(key))
+      end
+
+      def delete(key)
+        super(convert_key(key))
+      end
+
+      def values_at(*indices)
+        indices.collect { |key| self[convert_key(key)] }
+      end
+
+      protected
+
+        def convert_key(key)
+          key.is_a?(Symbol) ? key.to_s : key
+        end
+
+        # Magic predicates. For instance:
+        #
+        #   options.force? # => !!options['force']
+        #
+        def method_missing(method, *args, &block)
+          method = method.to_s
+          if method =~ /^(\w+)\?$/
+            !!self[$1]
+          else 
+            self[method]
+          end
+        end
+
+    end
+  end
+end

data/lib/thor/core_ext/ordered_hash.rb

@@ -0,0 +1,133 @@
+class Thor #:nodoc:
+  module CoreExt #:nodoc:
+
+    # 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:
+      Node = Struct.new(:key, :value, :next, :prev)
+      include Enumerable
+
+      def initialize
+        @hash = {}
+      end
+
+      # Called on clone. It gets all the notes from the cloned object, dup them
+      # and assign the duped objects siblings.
+      #
+      def initialize_copy(other)
+        @hash = {}
+
+        array = []
+        other.each do |key, value|
+          array << (@hash[key] = Node.new(key, value))
+        end
+
+        array.each_with_index do |node, i|
+          node.next = array[i + 1]
+          node.prev = array[i - 1] if i > 0
+        end
+
+        @first = array.first
+        @last  = array.last
+      end
+
+      def [](key)
+        @hash[key] && @hash[key].value
+      end
+
+      def []=(key, value)
+        if old = @hash[key]
+          node = old.dup
+          node.value = value
+
+          @first = node if @first == old
+          @last  = node if @last  == old
+
+          old.prev.next = node if old.prev
+          old.next.prev = node if old.next
+        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[key] = nil
+        value
+      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 keys
+        self.map { |k, v| k }
+      end
+
+      def values
+        self.map { |k, v| v }
+      end
+
+      def merge(other)
+        new = clone
+        other.each do |key, value|
+          new[key] = value
+        end
+        new
+      end
+
+      def merge!(other)
+        other.each do |key, value|
+          self[key] = value
+        end
+        self
+      end
+
+      def empty?
+        @hash.empty?
+      end
+
+      def to_a
+        inject([]) do |array, (key, value)|
+          array << [key, value]
+          array
+        end
+      end
+
+      def to_s
+        to_a.inspect
+      end
+      alias :inspect :to_s
+    end
+  end
+end

data/lib/thor/error.rb

@@ -0,0 +1,27 @@
+class Thor
+  # 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,90 @@
+class Thor::Group
+
+  class << self
+
+    # The descrition for this Thor::Group as a whole.
+    #
+    # ==== Parameters
+    # description<String>:: The description for this Thor::Group.
+    #
+    def desc(description=nil)
+      case description
+        # TODO When a symbol is given, read a file in the current directory
+        # when Symbol
+        #   @desc = File.read
+        when nil
+          @desc ||= from_superclass(:desc, nil)
+        else
+          @desc = description
+      end
+    end
+
+    # Start in Thor::Group works differently. It invokes all tasks inside the
+    # class and does not have to parse task options.
+    #
+    def start(args=ARGV, config={})
+      config[:shell] ||= Thor::Base.shell.new
+
+      if Thor::HELP_MAPPINGS.include?(args.first)
+        help(config[:shell])
+      else
+        opts = Thor::Options.new(class_options)
+        opts.parse(args)
+
+        new(opts.arguments, opts.options, config).invoke_all
+      end
+    rescue Thor::Error => e
+      config[:shell].error e.message
+    end
+
+    # Prints help information.
+    #
+    # ==== Options
+    # short:: When true, shows only usage.
+    #
+    def help(shell, options={})
+      if options[:short]
+        shell.say "#{self.namespace} #{self.class_options.map {|_,o| o.usage}.join(' ')}"
+      else
+        shell.say "Usage:"
+        shell.say "  #{self.namespace} #{self.arguments.map{|o| o.usage}.join(' ')}"
+        shell.say
+
+        list = self.class_options.map do |_, option|
+          next if option.argument?
+          [ option.usage, option.description || '' ]
+        end.compact
+
+        unless list.empty?
+          shell.say "Global options:"
+          shell.print_table(list, :emphasize_last => true, :ident => 2)
+          shell.say
+        end
+
+        shell.say self.desc if self.desc
+      end
+    end
+
+    protected
+
+      def baseclass #:nodoc:
+        Thor::Group
+      end
+
+      def valid_task?(meth) #:nodoc:
+        public_instance_methods.include?(meth)
+      end
+
+      def create_task(meth) #:nodoc:
+        tasks[meth.to_s] = Thor::Task.new(meth, nil, nil, nil)
+      end
+  end
+
+  # Invokes all tasks in the instance.
+  #
+  def invoke_all
+    self.class.all_tasks.map { |_, task| task.run(self) }
+  end
+
+  include Thor::Base
+end

data/lib/thor/option.rb

@@ -0,0 +1,210 @@
+class Thor
+  class Option
+    attr_reader :name, :description, :required, :type, :default, :aliases
+
+    VALID_TYPES = [:boolean, :numeric, :hash, :array, :string, :default]
+
+    def initialize(name, description=nil, required=nil, type=nil, default=nil, aliases=nil)
+      raise ArgumentError, "Option name can't be nil."                          if name.nil?
+      raise ArgumentError, "Option cannot be required and have default values." if required && !default.nil?
+      raise ArgumentError, "Type :#{type} is not valid for options."            if type && !VALID_TYPES.include?(type.to_sym)
+
+      @name        = name.to_s
+      @description = description
+      @required    = required || false
+      @type        = (type || :default).to_sym
+      @default     = default
+      @aliases     = [*aliases].compact
+    end
+
+    # This parse quick options given as method_options. It makes several
+    # assumptions, but you can be more specific using the option method.
+    #
+    #   parse :foo => "bar"
+    #   #=> Option foo with default value bar
+    #
+    #   parse [:foo, :baz] => "bar"
+    #   #=> Option foo with default value bar and alias :baz
+    #
+    #   parse :foo => :required
+    #   #=> Required option foo without default value
+    #
+    #   parse :foo => :optional
+    #   #=> Optional foo without default value
+    #
+    #   parse :foo => 2
+    #   #=> Option foo with default value 2 and type numeric
+    #
+    #   parse :foo => :numeric
+    #   #=> Option foo without default value and type numeric
+    #
+    #   parse :foo => true
+    #   #=> Option foo with default value true and type boolean
+    #
+    # The valid types are :boolean, :numeric, :hash, :array and :string. If none
+    # is given a default type is assumed. This default type accepts arguments as
+    # string (--foo=value) or booleans (just --foo).
+    #
+    # By default all options are optional, unless :required is given.
+    # 
+    def self.parse(key, value)
+      if key.is_a?(Array)
+        name, *aliases = key
+      else
+        name, aliases = key, []
+      end
+
+      name    = name.to_s
+      default = value
+
+      type = case value
+        when Symbol
+          default  = nil
+
+          if VALID_TYPES.include?(value)
+            value
+          elsif required = (value == :required)
+            :string
+          end
+        when TrueClass, FalseClass
+          :boolean
+        when Numeric
+          :numeric
+        when Hash, Array, String
+          value.class.name.downcase.to_sym
+      end
+
+      self.new(name.to_s, nil, required, type, default, aliases)
+    end
+
+    def argument?
+      false
+    end
+
+    def required?
+      required
+    end
+
+    def optional?
+      !required
+    end
+
+    def <=>(other)
+      self.position <=> other.position
+    end
+
+    # Returns true if this type requires an input to be given. Just :default
+    # and :boolean does not require an input.
+    #
+    def input_required?
+      [ :numeric, :hash, :array, :string ].include?(type)
+    end
+
+    def switch_name
+      @switch_name ||= dasherized? ? name : dasherize(name)
+    end
+
+    def human_name
+      @human_name ||= dasherized? ? undasherize(name) : name
+    end
+
+    def dasherized?
+      name.index('-') == 0
+    end
+
+    def undasherize(str)
+      str.sub(/^-{1,2}/, '')
+    end
+
+    def dasherize(str)
+      (str.length > 1 ? "--" : "-") + str
+    end
+
+    def usage
+      sample = formatted_default || formatted_value
+
+      sample = if sample
+        "#{switch_name}=#{sample}"
+      else
+        switch_name
+      end
+
+      sample = "[#{sample}]"                      unless required?
+      sample = "#{aliases.join(', ')}, #{sample}" unless aliases.empty?
+      sample
+    end
+
+    protected
+
+      def position
+        if argument?
+          -1
+        elsif required?
+          0
+        else
+          1
+        end
+      end
+
+      def formatted_default
+        return unless default
+
+        case type
+          when :boolean
+            nil
+          when :numeric
+            default.to_s
+          when :string, :default
+            default.empty? ? formatted_value : default.to_s
+          when :hash
+            if default.empty?
+              formatted_value
+            else
+              default.inject([]) do |mem, (key, value)|
+                mem << "#{key}:#{value}".gsub(/\s/, '_')
+                mem
+              end.join(' ')
+            end
+          when :array
+            default.empty? ? formatted_value : default.join(" ")
+        end
+      end
+
+      def formatted_value
+        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
+
+  # Argument is a subset of option. It does not support :boolean and :default
+  # as types.
+  #
+  class Argument < Option
+    VALID_TYPES = [:numeric, :hash, :array, :string]
+
+    def initialize(name, description=nil, required=true, type=:string, default=nil)
+      raise ArgumentError, "Argument name can't be nil."               if name.nil?
+      raise ArgumentError, "Type :#{type} is not valid for arguments." if type && !VALID_TYPES.include?(type.to_sym)
+
+      super(name, description, required, type || :string, default, [])
+    end
+
+    def argument?
+      true
+    end
+
+    def usage
+      required? ? formatted_value : "[#{formatted_value}]"
+    end
+  end
+end