thor 0.17.0 → 0.18.0

data/lib/thor/shell/basic.rb

@@ -61,7 +61,7 @@ class Thor
       def say(message="", color=nil, force_new_line=(message.to_s !~ /( |\t)\Z/))
         message = message.to_s
 
-        message = set_color(message, *color) if color
+        message = set_color(message, *color) if color && can_display_colors?
 
         spaces = "  " * padding
 
@@ -275,6 +275,10 @@ class Thor
 
     protected
 
+      def can_display_colors?
+        false
+      end
+
       def lookup_color(color)
         return color unless color.is_a?(Symbol)
         self.class.const_get(color.to_s.upcase)

data/lib/thor/shell/color.rb

@@ -94,6 +94,10 @@ class Thor
 
       protected
 
+        def can_display_colors?
+          stdout.tty?
+        end
+
         # Overwrite show_diff to show diff with colors if Diff::LCS is
         # available.
         #

data/lib/thor/shell/html.rb

@@ -73,6 +73,10 @@ class Thor
 
       protected
 
+        def can_display_colors?
+          true
+        end
+
         # Overwrite show_diff to show diff with colors if Diff::LCS is
         # available.
         #

data/lib/thor/util.rb

@@ -16,251 +16,255 @@ class Thor
   #
   module Util
 
-    # Receives a namespace and search for it in the Thor::Base subclasses.
-    #
-    # ==== Parameters
-    # namespace<String>:: The namespace to search for.
-    #
-    def self.find_by_namespace(namespace)
-      namespace = "default#{namespace}" if namespace.empty? || namespace =~ /^:/
-      Thor::Base.subclasses.find { |klass| klass.namespace == namespace }
-    end
+    class << self
 
-    # Receives a constant and converts it to a Thor namespace. Since Thor tasks
-    # can be added to a sandbox, this method is also responsable for removing
-    # the sandbox namespace.
-    #
-    # This method should not be used in general because it's used to deal with
-    # older versions of Thor. On current versions, if you need to get the
-    # namespace from a class, just call namespace on it.
-    #
-    # ==== Parameters
-    # constant<Object>:: The constant to be converted to the thor path.
-    #
-    # ==== Returns
-    # String:: If we receive Foo::Bar::Baz it returns "foo:bar:baz"
-    #
-    def self.namespace_from_thor_class(constant)
-      constant = constant.to_s.gsub(/^Thor::Sandbox::/, "")
-      constant = snake_case(constant).squeeze(":")
-      constant
-    end
+      # Receives a namespace and search for it in the Thor::Base subclasses.
+      #
+      # ==== Parameters
+      # namespace<String>:: The namespace to search for.
+      #
+      def find_by_namespace(namespace)
+        namespace = "default#{namespace}" if namespace.empty? || namespace =~ /^:/
+        Thor::Base.subclasses.find { |klass| klass.namespace == namespace }
+      end
 
-    # Given the contents, evaluate it inside the sandbox and returns the
-    # namespaces defined in the sandbox.
-    #
-    # ==== Parameters
-    # contents<String>
-    #
-    # ==== Returns
-    # Array[Object]
-    #
-    def self.namespaces_in_content(contents, file=__FILE__)
-      old_constants = Thor::Base.subclasses.dup
-      Thor::Base.subclasses.clear
+      # Receives a constant and converts it to a Thor namespace. Since Thor
+      # commands can be added to a sandbox, this method is also responsable for
+      # removing the sandbox namespace.
+      #
+      # This method should not be used in general because it's used to deal with
+      # older versions of Thor. On current versions, if you need to get the
+      # namespace from a class, just call namespace on it.
+      #
+      # ==== Parameters
+      # constant<Object>:: The constant to be converted to the thor path.
+      #
+      # ==== Returns
+      # String:: If we receive Foo::Bar::Baz it returns "foo:bar:baz"
+      #
+      def namespace_from_thor_class(constant)
+        constant = constant.to_s.gsub(/^Thor::Sandbox::/, "")
+        constant = snake_case(constant).squeeze(":")
+        constant
+      end
 
-      load_thorfile(file, contents)
+      # Given the contents, evaluate it inside the sandbox and returns the
+      # namespaces defined in the sandbox.
+      #
+      # ==== Parameters
+      # contents<String>
+      #
+      # ==== Returns
+      # Array[Object]
+      #
+      def namespaces_in_content(contents, file=__FILE__)
+        old_constants = Thor::Base.subclasses.dup
+        Thor::Base.subclasses.clear
 
-      new_constants = Thor::Base.subclasses.dup
-      Thor::Base.subclasses.replace(old_constants)
+        load_thorfile(file, contents)
 
-      new_constants.map!{ |c| c.namespace }
-      new_constants.compact!
-      new_constants
-    end
+        new_constants = Thor::Base.subclasses.dup
+        Thor::Base.subclasses.replace(old_constants)
 
-    # Returns the thor classes declared inside the given class.
-    #
-    def self.thor_classes_in(klass)
-      stringfied_constants = klass.constants.map { |c| c.to_s }
-      Thor::Base.subclasses.select do |subclass|
-        next unless subclass.name
-        stringfied_constants.include?(subclass.name.gsub("#{klass.name}::", ''))
+        new_constants.map!{ |c| c.namespace }
+        new_constants.compact!
+        new_constants
       end
-    end
-
-    # Receives a string and convert it to snake case. SnakeCase returns snake_case.
-    #
-    # ==== Parameters
-    # String
-    #
-    # ==== Returns
-    # String
-    #
-    def self.snake_case(str)
-      return str.downcase if str =~ /^[A-Z_]+$/
-      str.gsub(/\B[A-Z]/, '_\&').squeeze('_') =~ /_*(.*)/
-      return $+.downcase
-    end
-
-    # Receives a string and convert it to camel case. camel_case returns CamelCase.
-    #
-    # ==== Parameters
-    # String
-    #
-    # ==== Returns
-    # String
-    #
-    def self.camel_case(str)
-      return str if str !~ /_/ && str =~ /[A-Z]+.*/
-      str.split('_').map { |i| i.capitalize }.join
-    end
 
-    # Receives a namespace and tries to retrieve a Thor or Thor::Group class
-    # from it. It first searches for a class using the all the given namespace,
-    # if it's not found, removes the highest entry and searches for the class
-    # again. If found, returns the highest entry as the class name.
-    #
-    # ==== Examples
-    #
-    #   class Foo::Bar < Thor
-    #     def baz
-    #     end
-    #   end
-    #
-    #   class Baz::Foo < Thor::Group
-    #   end
-    #
-    #   Thor::Util.namespace_to_thor_class("foo:bar")     #=> Foo::Bar, nil # will invoke default task
-    #   Thor::Util.namespace_to_thor_class("baz:foo")     #=> Baz::Foo, nil
-    #   Thor::Util.namespace_to_thor_class("foo:bar:baz") #=> Foo::Bar, "baz"
-    #
-    # ==== Parameters
-    # namespace<String>
-    #
-    def self.find_class_and_task_by_namespace(namespace, fallback = true)
-      if namespace.include?(?:) # look for a namespaced task
-        pieces = namespace.split(":")
-        task   = pieces.pop
-        klass  = Thor::Util.find_by_namespace(pieces.join(":"))
-      end
-      unless klass # look for a Thor::Group with the right name
-        klass, task = Thor::Util.find_by_namespace(namespace), nil
+      # Returns the thor classes declared inside the given class.
+      #
+      def thor_classes_in(klass)
+        stringfied_constants = klass.constants.map { |c| c.to_s }
+        Thor::Base.subclasses.select do |subclass|
+          next unless subclass.name
+          stringfied_constants.include?(subclass.name.gsub("#{klass.name}::", ''))
+        end
       end
-      if !klass && fallback # try a task in the default namespace
-        task = namespace
-        klass = Thor::Util.find_by_namespace('')
+
+      # Receives a string and convert it to snake case. SnakeCase returns snake_case.
+      #
+      # ==== Parameters
+      # String
+      #
+      # ==== Returns
+      # String
+      #
+      def snake_case(str)
+        return str.downcase if str =~ /^[A-Z_]+$/
+        str.gsub(/\B[A-Z]/, '_\&').squeeze('_') =~ /_*(.*)/
+        return $+.downcase
       end
-      return klass, task
-    end
 
-    # Receives a path and load the thor file in the path. The file is evaluated
-    # inside the sandbox to avoid namespacing conflicts.
-    #
-    def self.load_thorfile(path, content=nil, debug=false)
-      content ||= File.binread(path)
+      # Receives a string and convert it to camel case. camel_case returns CamelCase.
+      #
+      # ==== Parameters
+      # String
+      #
+      # ==== Returns
+      # String
+      #
+      def camel_case(str)
+        return str if str !~ /_/ && str =~ /[A-Z]+.*/
+        str.split('_').map { |i| i.capitalize }.join
+      end
 
-      begin
-        Thor::Sandbox.class_eval(content, path)
-      rescue Exception => e
-        $stderr.puts("WARNING: unable to load thorfile #{path.inspect}: #{e.message}")
-        if debug
-          $stderr.puts(*e.backtrace)
-        else
-          $stderr.puts(e.backtrace.first)
+      # Receives a namespace and tries to retrieve a Thor or Thor::Group class
+      # from it. It first searches for a class using the all the given namespace,
+      # if it's not found, removes the highest entry and searches for the class
+      # again. If found, returns the highest entry as the class name.
+      #
+      # ==== Examples
+      #
+      #   class Foo::Bar < Thor
+      #     def baz
+      #     end
+      #   end
+      #
+      #   class Baz::Foo < Thor::Group
+      #   end
+      #
+      #   Thor::Util.namespace_to_thor_class("foo:bar")     #=> Foo::Bar, nil # will invoke default command
+      #   Thor::Util.namespace_to_thor_class("baz:foo")     #=> Baz::Foo, nil
+      #   Thor::Util.namespace_to_thor_class("foo:bar:baz") #=> Foo::Bar, "baz"
+      #
+      # ==== Parameters
+      # namespace<String>
+      #
+      def find_class_and_command_by_namespace(namespace, fallback = true)
+        if namespace.include?(?:) # look for a namespaced command
+          pieces  = namespace.split(":")
+          command = pieces.pop
+          klass   = Thor::Util.find_by_namespace(pieces.join(":"))
+        end
+        unless klass # look for a Thor::Group with the right name
+          klass, command = Thor::Util.find_by_namespace(namespace), nil
+        end
+        if !klass && fallback # try a command in the default namespace
+          command = namespace
+          klass   = Thor::Util.find_by_namespace('')
         end
+        return klass, command
       end
-    end
+      alias find_class_and_task_by_namespace find_class_and_command_by_namespace
+
+      # Receives a path and load the thor file in the path. The file is evaluated
+      # inside the sandbox to avoid namespacing conflicts.
+      #
+      def load_thorfile(path, content=nil, debug=false)
+        content ||= File.binread(path)
 
-    def self.user_home
-      @@user_home ||= if ENV["HOME"]
-        ENV["HOME"]
-      elsif ENV["USERPROFILE"]
-        ENV["USERPROFILE"]
-      elsif ENV["HOMEDRIVE"] && ENV["HOMEPATH"]
-        File.join(ENV["HOMEDRIVE"], ENV["HOMEPATH"])
-      elsif ENV["APPDATA"]
-        ENV["APPDATA"]
-      else
         begin
-          File.expand_path("~")
-        rescue
-          if File::ALT_SEPARATOR
-            "C:/"
+          Thor::Sandbox.class_eval(content, path)
+        rescue Exception => e
+          $stderr.puts("WARNING: unable to load thorfile #{path.inspect}: #{e.message}")
+          if debug
+            $stderr.puts(*e.backtrace)
           else
-            "/"
+            $stderr.puts(e.backtrace.first)
           end
         end
       end
-    end
 
-    # Returns the root where thor files are located, depending on the OS.
-    #
-    def self.thor_root
-      File.join(user_home, ".thor").gsub(/\\/, '/')
-    end
+      def user_home
+        @@user_home ||= if ENV["HOME"]
+          ENV["HOME"]
+        elsif ENV["USERPROFILE"]
+          ENV["USERPROFILE"]
+        elsif ENV["HOMEDRIVE"] && ENV["HOMEPATH"]
+          File.join(ENV["HOMEDRIVE"], ENV["HOMEPATH"])
+        elsif ENV["APPDATA"]
+          ENV["APPDATA"]
+        else
+          begin
+            File.expand_path("~")
+          rescue
+            if File::ALT_SEPARATOR
+              "C:/"
+            else
+              "/"
+            end
+          end
+        end
+      end
+
+      # Returns the root where thor files are located, depending on the OS.
+      #
+      def thor_root
+        File.join(user_home, ".thor").gsub(/\\/, '/')
+      end
 
-    # Returns the files in the thor root. On Windows thor_root will be something
-    # like this:
-    #
-    #   C:\Documents and Settings\james\.thor
-    #
-    # If we don't #gsub the \ character, Dir.glob will fail.
-    #
-    def self.thor_root_glob
-      files = Dir["#{escape_globs(thor_root)}/*"]
+      # Returns the files in the thor root. On Windows thor_root will be something
+      # like this:
+      #
+      #   C:\Documents and Settings\james\.thor
+      #
+      # If we don't #gsub the \ character, Dir.glob will fail.
+      #
+      def thor_root_glob
+        files = Dir["#{escape_globs(thor_root)}/*"]
 
-      files.map! do |file|
-        File.directory?(file) ? File.join(file, "main.thor") : file
+        files.map! do |file|
+          File.directory?(file) ? File.join(file, "main.thor") : file
+        end
       end
-    end
 
-    # Where to look for Thor files.
-    #
-    def self.globs_for(path)
-      path = escape_globs(path)
-      ["#{path}/Thorfile", "#{path}/*.thor", "#{path}/tasks/*.thor", "#{path}/lib/tasks/*.thor"]
-    end
+      # Where to look for Thor files.
+      #
+      def globs_for(path)
+        path = escape_globs(path)
+        ["#{path}/Thorfile", "#{path}/*.thor", "#{path}/tasks/*.thor", "#{path}/lib/tasks/*.thor"]
+      end
 
-    # Return the path to the ruby interpreter taking into account multiple
-    # installations and windows extensions.
-    #
-    def self.ruby_command
-      @ruby_command ||= begin
-        ruby_name = RbConfig::CONFIG['ruby_install_name']
-        ruby = File.join(RbConfig::CONFIG['bindir'], ruby_name)
-        ruby << RbConfig::CONFIG['EXEEXT']
+      # Return the path to the ruby interpreter taking into account multiple
+      # installations and windows extensions.
+      #
+      def ruby_command
+        @ruby_command ||= begin
+          ruby_name = RbConfig::CONFIG['ruby_install_name']
+          ruby = File.join(RbConfig::CONFIG['bindir'], ruby_name)
+          ruby << RbConfig::CONFIG['EXEEXT']
 
-        # avoid using different name than ruby (on platforms supporting links)
-        if ruby_name != 'ruby' && File.respond_to?(:readlink)
-          begin
-            alternate_ruby = File.join(RbConfig::CONFIG['bindir'], 'ruby')
-            alternate_ruby << RbConfig::CONFIG['EXEEXT']
+          # avoid using different name than ruby (on platforms supporting links)
+          if ruby_name != 'ruby' && File.respond_to?(:readlink)
+            begin
+              alternate_ruby = File.join(RbConfig::CONFIG['bindir'], 'ruby')
+              alternate_ruby << RbConfig::CONFIG['EXEEXT']
 
-            # ruby is a symlink
-            if File.symlink? alternate_ruby
-              linked_ruby = File.readlink alternate_ruby
+              # ruby is a symlink
+              if File.symlink? alternate_ruby
+                linked_ruby = File.readlink alternate_ruby
 
-              # symlink points to 'ruby_install_name'
-              ruby = alternate_ruby if linked_ruby == ruby_name || linked_ruby == ruby
+                # symlink points to 'ruby_install_name'
+                ruby = alternate_ruby if linked_ruby == ruby_name || linked_ruby == ruby
+              end
+            rescue NotImplementedError
+              # just ignore on windows
             end
-          rescue NotImplementedError
-            # just ignore on windows
           end
+
+          # escape string in case path to ruby executable contain spaces.
+          ruby.sub!(/.*\s.*/m, '"\&"')
+          ruby
         end
+      end
 
-        # escape string in case path to ruby executable contain spaces.
-        ruby.sub!(/.*\s.*/m, '"\&"')
-        ruby
+      # Returns a string that has had any glob characters escaped.
+      # The glob characters are `* ? { } [ ]`.
+      #
+      # ==== Examples
+      #
+      #   Thor::Util.escape_globs('[apps]')   # => '\[apps\]'
+      #
+      # ==== Parameters
+      # String
+      #
+      # ==== Returns
+      # String
+      #
+      def escape_globs(path)
+        path.to_s.gsub(/[*?{}\[\]]/, '\\\\\\&')
       end
-    end
 
-    # Returns a string that has had any glob characters escaped.
-    # The glob characters are `* ? { } [ ]`.
-    #
-    # ==== Examples
-    #
-    #   Thor::Util.escape_globs('[apps]')   # => '\[apps\]'
-    #
-    # ==== Parameters
-    # String
-    #
-    # ==== Returns
-    # String
-    #
-    def self.escape_globs(path)
-      path.to_s.gsub(/[*?{}\[\]]/, '\\\\\\&')
     end
-
   end
 end