wycats-thor 0.9.8 → 0.10.26

data/lib/thor/shell/basic.rb

@@ -0,0 +1,221 @@
+require 'tempfile'
+
+class Thor
+  module Shell
+    class Basic
+      attr_accessor :base, :padding
+
+      # Initialize base and padding to nil.
+      #
+      def initialize #:nodoc:
+        @base, @padding = nil, 0
+      end
+
+      # Do not allow padding to be less than zero.
+      #
+      def padding=(value) #:nodoc:
+        @padding = [0, value].max
+      end
+
+      # Ask something to the user and receives a response.
+      #
+      # ==== Example
+      # ask("What is your name?")
+      #
+      def ask(statement, color=nil)
+        say("#{statement} ", color)
+        $stdin.gets.strip
+      end
+
+      # Say (print) something to the user. If the sentence ends with a whitespace
+      # or tab character, a new line is not appended (print + flush). Otherwise
+      # are passed straight to puts (behavior got from Highline).
+      #
+      # ==== Example
+      # say("I know you knew that.")
+      #
+      def say(message="", color=nil, force_new_line=false)
+        message  = message.to_s
+        new_line = force_new_line || !(message[-1, 1] == " " || message[-1, 1] == "\t")
+        message  = set_color(message, color) if color
+
+        if new_line
+          $stdout.puts(message)
+        else
+          $stdout.print(message)
+          $stdout.flush
+        end
+      end
+
+      # Say a status with the given color and appends the message. Since this
+      # method is used frequently by actions, it allows nil or false to be given
+      # in log_status, avoiding the message from being shown. If a Symbol is
+      # given in log_status, it's used as the color.
+      #
+      def say_status(status, message, log_status=true) #:nodoc:
+        return if quiet? || log_status == false
+        spaces = "  " * (padding + 1)
+        color  = log_status.is_a?(Symbol) ? log_status : :green
+
+        status = status.to_s.rjust(12)
+        status = set_color status, color, true if color
+        say "#{status}#{spaces}#{message}", nil, true
+      end
+
+      # Make a question the to user and returns true if the user replies "y" or
+      # "yes".
+      #
+      def yes?(statement, color=nil)
+        ask(statement, color) =~ is?(:yes)
+      end
+
+      # Make a question the to user and returns true if the user replies "n" or
+      # "no".
+      #
+      def no?(statement, color=nil)
+        !yes?(statement, color)
+      end
+
+      # Prints a list of items.
+      #
+      # ==== Parameters
+      # list<Array[String, String, ...]>
+      # mode<Symbol>:: Can be :rows or :inline. Defaults to :rows.
+      #
+      def print_list(list, mode=:rows)
+        return if list.empty?
+
+        content = case mode
+          when :inline
+            last = list.pop
+            "#{list.join(", ")}, and #{last}"
+          else # rows
+            list.join("\n")
+        end
+
+        $stdout.puts content
+      end
+
+      # Prints a table.
+      #
+      # ==== Parameters
+      # Array[Array[String, String, ...]]
+      #
+      # ==== Options
+      # ident<Integer>:: Ident the first column by ident value.
+      # emphasize_last<Boolean>:: When true, add a different behavior to the last column.
+      #
+      def print_table(table, options={})
+        return if table.empty?
+
+        formats = []
+        0.upto(table.first.length - 2) do |i|
+          maxima = table.max{ |a,b| a[i].size <=> b[i].size }[i].size
+          formats << "%-#{maxima + 2}s"
+        end
+
+        formats[0] = formats[0].insert(0, " " * options[:ident]) if options[:ident]
+        formats << "%s"
+
+        if options[:emphasize_last]
+          table.each do |row|
+            next if row[-1].empty?
+            row[-1] = "# #{row[-1]}"
+          end
+        end
+
+        table.each do |row|
+          row.each_with_index do |column, i|
+            $stdout.print formats[i] % column.to_s
+          end
+          $stdout.puts
+        end
+      end
+
+      # Deals with file collision and returns true if the file should be
+      # overwriten and false otherwise. If a block is given, it uses the block
+      # response as the content for the diff.
+      #
+      # ==== Parameters
+      # destination<String>:: the destination file to solve conflicts
+      # block<Proc>:: an optional proc that returns the value to be used in diff
+      #
+      def file_collision(destination)
+        return true if @always_force
+        options = block_given? ? "[Ynaqdh]" : "[Ynaqh]"
+
+        while true
+          answer = ask %[Overwrite #{destination}? (enter "h" for help) #{options}]
+
+          case answer
+            when is?(:yes), is?(:force)
+              return true
+            when is?(:no), is?(:skip)
+              return false
+            when is?(:always)
+              return @always_force = true
+            when is?(:quit)
+              say 'Aborting...'
+              raise SystemExit
+            when is?(:diff)
+              show_diff(destination, yield) if block_given?
+              say 'Retrying...'
+            else
+              say file_collision_help
+          end
+        end
+      end
+
+      # Called if something goes wrong during the execution. This is used by Thor
+      # internally and should not be used inside your scripts. If someone went
+      # wrong, you can always raise an exception. If you raise a Thor::Error, it
+      # will be rescued and wrapped in the method below.
+      #
+      def error(statement) #:nodoc:
+        $stderr.puts statement
+      end
+
+      protected
+
+        def set_color(string, color, bold=false)
+          string
+        end
+
+        def is?(value)
+          value = value.to_s
+
+          if value.size == 1
+            /\A#{value}\z/i
+          else
+            /\A(#{value}|#{value[0,1]})\z/i
+          end
+        end
+
+        def file_collision_help
+<<HELP
+Y - yes, overwrite
+n - no, do not overwrite
+a - all, overwrite this and all others
+q - quit, abort
+d - diff, show the differences between the old and the new
+h - help, show this help
+HELP
+        end
+
+        def show_diff(destination, content)
+          diff_cmd = ENV['THOR_DIFF'] || ENV['RAILS_DIFF'] || 'diff -u'
+
+          Tempfile.open(File.basename(destination), File.dirname(destination)) do |temp|
+            temp.write content
+            temp.rewind
+            say `#{diff_cmd} "#{destination}" "#{temp.path}"`
+          end
+        end
+
+        def quiet?
+          base && base.options[:quiet]
+        end
+
+    end
+  end
+end

data/lib/thor/shell/color.rb

@@ -0,0 +1,106 @@
+require 'thor/shell/basic'
+
+class Thor
+  module Shell
+    # Set color in the output. Got color values from HighLine.
+    #
+    class Color < Basic
+      # Embed in a String to clear all previous ANSI sequences.
+      CLEAR      = "\e[0m"
+      # The start of an ANSI bold sequence.
+      BOLD       = "\e[1m"
+
+      # Set the terminal's foreground ANSI color to black.
+      BLACK      = "\e[30m"
+      # Set the terminal's foreground ANSI color to red.
+      RED        = "\e[31m"
+      # Set the terminal's foreground ANSI color to green.
+      GREEN      = "\e[32m"
+      # Set the terminal's foreground ANSI color to yellow.
+      YELLOW     = "\e[33m"
+      # Set the terminal's foreground ANSI color to blue.
+      BLUE       = "\e[34m"
+      # Set the terminal's foreground ANSI color to magenta.
+      MAGENTA    = "\e[35m"
+      # Set the terminal's foreground ANSI color to cyan.
+      CYAN       = "\e[36m"
+      # Set the terminal's foreground ANSI color to white.
+      WHITE      = "\e[37m"
+
+      # Set the terminal's background ANSI color to black.
+      ON_BLACK   = "\e[40m"
+      # Set the terminal's background ANSI color to red.
+      ON_RED     = "\e[41m"
+      # Set the terminal's background ANSI color to green.
+      ON_GREEN   = "\e[42m"
+      # Set the terminal's background ANSI color to yellow.
+      ON_YELLOW  = "\e[43m"
+      # Set the terminal's background ANSI color to blue.
+      ON_BLUE    = "\e[44m"
+      # Set the terminal's background ANSI color to magenta.
+      ON_MAGENTA = "\e[45m"
+      # Set the terminal's background ANSI color to cyan.
+      ON_CYAN    = "\e[46m"
+      # Set the terminal's background ANSI color to white.
+      ON_WHITE   = "\e[47m"
+
+      protected
+
+        # Set color by using a string or one of the defined constants. Based
+        # on Highline implementation. CLEAR is automatically be embedded to
+        # the end of the returned String.
+        #
+        def set_color(string, color, bold=false)
+          color = self.class.const_get(color.to_s.upcase) if color.is_a?(Symbol)
+          bold  = bold ? BOLD : ""
+          "#{bold}#{color}#{string}#{CLEAR}"
+        end
+
+        # Overwrite show_diff to show diff with colors if Diff::LCS is
+        # available.
+        #
+        def show_diff(destination, content)
+          if diff_lcs_loaded? && ENV['THOR_DIFF'].nil? && ENV['RAILS_DIFF'].nil?
+            actual  = File.read(destination).to_s.split("\n")
+            content = content.to_s.split("\n")
+
+            Diff::LCS.sdiff(actual, content).each do |diff|
+              output_diff_line(diff)
+            end
+          else
+            super
+          end
+        end
+
+        def output_diff_line(diff)
+          case diff.action
+            when '-'
+              say "- #{diff.old_element.chomp}", :red
+            when '+'
+              say "+ #{diff.new_element.chomp}", :green
+            when '!'
+              say "- #{diff.old_element.chomp}", :red
+              say "+ #{diff.new_element.chomp}", :green
+            else
+              say "  #{diff.old_element.chomp}"
+          end
+        end
+
+        # Check if Diff::LCS is loaded. If it is, use it to create pretty output
+        # for diff.
+        #
+        def diff_lcs_loaded?
+          return true  if defined?(Diff::LCS)
+          return @diff_lcs_loaded unless @diff_lcs_loaded.nil?
+
+          @diff_lcs_loaded = begin
+            require 'diff/lcs'
+            true
+          rescue LoadError
+            false
+          end
+        end
+
+    end
+  end
+end

data/lib/thor/shell.rb

@@ -0,0 +1,72 @@
+require 'thor/shell/color'
+
+class Thor
+  module Base
+    # Returns the shell used in all Thor classes. Default to color one.
+    #
+    def self.shell
+      @shell ||= Thor::Shell::Color
+    end
+
+    # Sets the shell used in all Thor classes.
+    #
+    def self.shell=(klass)
+      @shell = klass
+    end
+  end
+
+  module Shell
+    SHELL_DELEGATED_METHODS = [:ask, :yes?, :no?, :say, :say_status, :print_list, :print_table]
+
+    # Add shell to initialize config values.
+    #
+    # ==== Configuration
+    # shell<Object>:: An instance of the shell to be used.
+    #
+    # ==== Examples
+    #
+    #   class MyScript < Thor
+    #     argument :first, :type => :numeric
+    #   end
+    #
+    #   MyScript.new [1.0], { :foo => :bar }, :shell => Thor::Shell::Basic.new
+    #
+    def initialize(args=[], options={}, config={})
+      super
+      self.shell = config[:shell]
+      self.shell.base ||= self if self.shell.respond_to?(:base)
+    end
+
+    # Holds the shell for the given Thor instance. If no shell is given,
+    # it gets a default shell from Thor::Base.shell.
+    #
+    def shell
+      @shell ||= Thor::Base.shell.new
+    end
+
+    # Sets the shell for this thor class.
+    #
+    def shell=(shell)
+      @shell = shell
+    end
+
+    # Common methods that are delegated to the shell.
+    #
+    SHELL_DELEGATED_METHODS.each do |method|
+      module_eval <<-METHOD, __FILE__, __LINE__
+        def #{method}(*args)
+          shell.#{method}(*args)
+        end
+      METHOD
+    end
+
+    protected
+
+      # Allow shell to be shared between invocations.
+      #
+      def _shared_configuration
+        super.merge!(:shell => self.shell)
+      end
+
+  end
+end

data/lib/thor/task.rb

@@ -1,79 +1,108 @@
-require 'thor/error'
-require 'thor/util'
-
 class Thor
-  class Task < Struct.new(:meth, :description, :usage, :opts, :klass)
-    
-    def self.dynamic(meth, klass)
-      new(meth, "A dynamically-generated task", meth.to_s, nil, klass)
+  class Task < Struct.new(:name, :description, :usage, :options)
+
+    # Creates a dynamic task. Dynamic tasks are created on demand to allow method
+    # missing calls (since a method missing does not have a task object for it).
+    #
+    def self.dynamic(name)
+      new(name, "A dynamically-generated task", name.to_s)
     end
-    
-    def initialize(*args)
-      # keep the original opts - we need them later on
-      @options = args[3] || {}
-      super
+
+    def initialize(name, description, usage, options=nil)
+      super(name.to_s, description, usage, options || {})
+    end
+
+    def initialize_copy(other)
+      super(other)
+      self.options = other.options.dup if other.options
     end
 
-    def parse(obj, args)
-      list, hash = parse_args(args)
-      obj.options = hash
-      run(obj, *list)
+    def short_description
+      description.split("\n").first if description
     end
 
-    def run(obj, *params)
-      raise NoMethodError, "the `#{meth}' task of #{obj.class} is private" if
-        (obj.private_methods + obj.protected_methods).include?(meth)
-      
-      obj.send(meth, *params)
+    # By default, a task invokes a method in the thor class. You can change this
+    # implementation to create custom tasks.
+    #
+    def run(instance, args=[])
+      raise UndefinedTaskError, "the '#{name}' task of #{instance.class} is private" unless public_method?(instance)
+      instance.send(name, *args)
     rescue ArgumentError => e
-      # backtrace sans anything in this file
-      backtrace = e.backtrace.reject {|frame| frame =~ /^#{Regexp.escape(__FILE__)}/}
-      # and sans anything that got us here
-      backtrace -= caller
-      raise e unless backtrace.empty?
-    
-      # okay, they really did call it wrong
-      raise Error, "`#{meth}' was called incorrectly. Call as `#{formatted_usage}'"
+      parse_argument_error(instance, e, caller)
     rescue NoMethodError => e
-      begin
-        raise e unless e.message =~ /^undefined method `#{meth}' for #{Regexp.escape(obj.inspect)}$/
-      rescue
-        raise e
-      end
-      raise Error, "The #{namespace false} namespace doesn't have a `#{meth}' task"
+      parse_no_method_error(instance, e)
     end
 
-    def namespace(remove_default = true)
-      Thor::Util.constant_to_thor_path(klass, remove_default)
+    # Returns the formatted usage. If a class is given, the class arguments are
+    # injected in the usage.
+    #
+    def formatted_usage(klass=nil, namespace=false)
+      formatted = ''
+      formatted << "#{klass.namespace.gsub(/^default/,'')}:" if klass && namespace
+      formatted << formatted_arguments(klass)
+      formatted << " #{formatted_options}"
+      formatted.strip!
+      formatted
     end
 
-    def with_klass(klass)
-      new = self.dup
-      new.klass = klass
-      new
-    end
-    
-    def opts
-      return super unless super.kind_of? Hash
-      @_opts ||= Options.new(super)
-    end
-        
-    def full_opts
-      @_full_opts ||= Options.new((klass.opts || {}).merge(@options))
+    # Injects the class arguments into the task usage.
+    #
+    def formatted_arguments(klass)
+      if klass && !klass.arguments.empty?
+        usage.to_s.gsub(/^#{name}/) do |match|
+          match << " " << klass.arguments.map{ |a| a.usage }.join(' ')
+        end
+      else
+        usage.to_s
+      end
     end
-    
-    def formatted_usage(namespace = false)
-      (namespace ? self.namespace + ':' : '') + usage +
-        (opts ? " " + opts.formatted_usage : "")
+
+    # Returns the options usage for this task.
+    #
+    def formatted_options
+      @formatted_options ||= options.map{ |_, o| o.usage }.sort.join(" ")
     end
 
     protected
 
-    def parse_args(args)
-      return [[], {}] if args.nil?
-      hash = full_opts.parse(args)
-      list = full_opts.non_opts
-      [list, hash]
-    end
+      # Given a target, checks if this class name is not a private/protected method.
+      #
+      def public_method?(instance)
+        collection = instance.private_methods + instance.protected_methods
+        !(collection).include?(name.to_s) && !(collection).include?(name.to_sym) # For Ruby 1.9
+      end
+
+      # Clean everything that comes from the Thor gempath and remove the caller.
+      #
+      def sans_backtrace(backtrace, caller)
+        dirname = /^#{Regexp.escape(File.dirname(__FILE__))}/
+        saned  = backtrace.reject { |frame| frame =~ dirname }
+        saned -= caller
+      end
+
+      def parse_argument_error(instance, e, caller)
+        backtrace = sans_backtrace(e.backtrace, caller)
+
+        if backtrace.empty? && e.message =~ /wrong number of arguments/
+          if instance.is_a?(Thor::Group)
+            raise e, "'#{name}' was called incorrectly. Are you sure it has arity equals to 0?"
+          else
+            raise InvocationError, "'#{name}' was called incorrectly. Call as " <<
+                                   "'#{formatted_usage(instance.class, true)}'"
+          end
+        else
+          raise e
+        end
+      end
+
+      def parse_no_method_error(instance, e)
+        if e.message =~ /^undefined method `#{name}' for #{Regexp.escape(instance.to_s)}$/
+          raise UndefinedTaskError, "The #{instance.class.namespace} namespace " <<
+                                    "doesn't have a '#{name}' task"
+        else
+          raise e
+        end
+      end
+
   end
 end