bundler 1.3.6 → 1.4.0.pre.1

data/lib/bundler/vendor/thor/rake_compat.rb

@@ -6,12 +6,13 @@ class Thor
   # rake package tasks. For example, to use rspec rake tasks, one can do:
   #
   #   require 'thor/rake_compat'
+  #   require 'rspec/core/rake_task'
   #
   #   class Default < Thor
   #     include Thor::RakeCompat
   #
-  #     Spec::Rake::SpecTask.new(:spec) do |t|
-  #       t.spec_opts = ['--options', "spec/spec.opts"]
+  #     RSpec::Core::RakeTask.new(:spec) do |t|
+  #       t.spec_opts = ['--options', "./.rspec"]
   #       t.spec_files = FileList['spec/**/*_spec.rb']
   #     end
   #   end

data/lib/bundler/vendor/thor/runner.rb

@@ -1,6 +1,6 @@
 require 'thor'
 require 'thor/group'
-require 'thor/core_ext/file_binary_read'
+require 'thor/core_ext/io_binary_read'
 
 require 'fileutils'
 require 'open-uri'
@@ -16,33 +16,33 @@ class Thor::Runner < Thor #:nodoc:
   def help(meth = nil)
     if meth && !self.respond_to?(meth)
       initialize_thorfiles(meth)
-      klass, task = Thor::Util.find_class_and_task_by_namespace(meth)
-      self.class.handle_no_task_error(task, false) if klass.nil?
-      klass.start(["-h", task].compact, :shell => self.shell)
+      klass, command = Thor::Util.find_class_and_command_by_namespace(meth)
+      self.class.handle_no_command_error(command, false) if klass.nil?
+      klass.start(["-h", command].compact, :shell => self.shell)
     else
       super
     end
   end
 
-  # If a task is not found on Thor::Runner, method missing is invoked and
-  # Thor::Runner is then responsible for finding the task in all classes.
+  # If a command is not found on Thor::Runner, method missing is invoked and
+  # Thor::Runner is then responsible for finding the command in all classes.
   #
   def method_missing(meth, *args)
     meth = meth.to_s
     initialize_thorfiles(meth)
-    klass, task = Thor::Util.find_class_and_task_by_namespace(meth)
-    self.class.handle_no_task_error(task, false) if klass.nil?
-    args.unshift(task) if task
+    klass, command = Thor::Util.find_class_and_command_by_namespace(meth)
+    self.class.handle_no_command_error(command, false) if klass.nil?
+    args.unshift(command) if command
     klass.start(args, :shell => self.shell)
   end
 
-  desc "install NAME", "Install an optionally named Thor file into your system tasks"
+  desc "install NAME", "Install an optionally named Thor file into your system commands"
   method_options :as => :string, :relative => :boolean, :force => :boolean
   def install(name)
     initialize_thorfiles
 
     # If a directory name is provided as the argument, look for a 'main.thor'
-    # task in said directory.
+    # command in said directory.
     begin
       if File.directory?(File.expand_path(name))
         base, package = File.join(name, "main.thor"), :directory
@@ -143,14 +143,14 @@ class Thor::Runner < Thor #:nodoc:
     end
   end
 
-  desc "installed", "List the installed Thor modules and tasks"
+  desc "installed", "List the installed Thor modules and commands"
   method_options :internal => :boolean
   def installed
     initialize_thorfiles(nil, true)
     display_klasses(true, options["internal"])
   end
 
-  desc "list [SEARCH]", "List the available thor tasks (--substring means .*SEARCH)"
+  desc "list [SEARCH]", "List the available thor commands (--substring means .*SEARCH)"
   method_options :substring => :boolean, :group => :string, :all => :boolean, :debug => :boolean
   def list(search="")
     initialize_thorfiles
@@ -168,8 +168,8 @@ class Thor::Runner < Thor #:nodoc:
 
   private
 
-    def self.banner(task, all = false, subcommand = false)
-      "thor " + task.formatted_usage(self, all, subcommand)
+    def self.banner(command, all = false, subcommand = false)
+      "thor " + command.formatted_usage(self, all, subcommand)
     end
 
     def thor_root
@@ -206,7 +206,7 @@ class Thor::Runner < Thor #:nodoc:
     # in the thor_root instead of loading them all.
     #
     # By default, it also traverses the current path until find Thor files, as
-    # described in thorfiles. This look up can be skipped by suppliying
+    # described in thorfiles. This look up can be skipped by supplying
     # skip_lookup true.
     #
     def initialize_thorfiles(relevant_to=nil, skip_lookup=false)
@@ -276,25 +276,25 @@ class Thor::Runner < Thor #:nodoc:
     def display_klasses(with_modules=false, show_internal=false, klasses=Thor::Base.subclasses)
       klasses -= [Thor, Thor::Runner, Thor::Group] unless show_internal
 
-      raise Error, "No Thor tasks available" if klasses.empty?
+      raise Error, "No Thor commands available" if klasses.empty?
       show_modules if with_modules && !thor_yaml.empty?
 
       list = Hash.new { |h,k| h[k] = [] }
       groups = klasses.select { |k| k.ancestors.include?(Thor::Group) }
 
       # Get classes which inherit from Thor
-      (klasses - groups).each { |k| list[k.namespace.split(":").first] += k.printable_tasks(false) }
+      (klasses - groups).each { |k| list[k.namespace.split(":").first] += k.printable_commands(false) }
 
       # Get classes which inherit from Thor::Base
-      groups.map! { |k| k.printable_tasks(false).first }
+      groups.map! { |k| k.printable_commands(false).first }
       list["root"] = groups
 
       # Order namespaces with default coming first
       list = list.sort{ |a,b| a[0].sub(/^default/, '') <=> b[0].sub(/^default/, '') }
-      list.each { |n, tasks| display_tasks(n, tasks) unless tasks.empty? }
+      list.each { |n, commands| display_commands(n, commands) unless commands.empty? }
     end
 
-    def display_tasks(namespace, list) #:nodoc:
+    def display_commands(namespace, list) #:nodoc:
       list.sort!{ |a,b| a[0] <=> b[0] }
 
       say shell.set_color(namespace, :blue, true)
@@ -303,6 +303,7 @@ class Thor::Runner < Thor #:nodoc:
       print_table(list, :truncate => true)
       say
     end
+    alias display_tasks display_commands
 
     def show_modules #:nodoc:
       info  = []

data/lib/bundler/vendor/thor/shell/basic.rb

@@ -47,8 +47,13 @@ class Thor
       #
       def ask(statement, *args)
         options = args.last.is_a?(Hash) ? args.pop : {}
+        color = args.first
 
-        options[:limited_to] ? ask_filtered(statement, options[:limited_to], *args) : ask_simply(statement, *args)
+        if options[:limited_to]
+          ask_filtered(statement, color, options)
+        else
+          ask_simply(statement, color, options)
+        end
       end
 
       # Say (print) something to the user. If the sentence ends with a whitespace
@@ -61,7 +66,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
 
@@ -226,20 +231,20 @@ class Thor
           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
+          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
@@ -275,6 +280,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)
@@ -368,17 +377,30 @@ HELP
         end
       end
 
-      def ask_simply(statement, color=nil)
-        say("#{statement} ", color)
-        stdin.gets.tap{|text| text.strip! if text}
+      def ask_simply(statement, color, options)
+        default = options[:default]
+        message = [statement, ("(#{default})" if default), nil].uniq.join(" ")
+        say(message, color)
+        result = stdin.gets
+
+        return unless result
+
+        result.strip!
+
+        if default && result == ""
+          default
+        else
+          result
+        end
       end
 
-      def ask_filtered(statement, answer_set, *args)
+      def ask_filtered(statement, color, options)
+        answer_set = options[:limited_to]
         correct_answer = nil
         until correct_answer
-          answer = ask_simply("#{statement} #{answer_set.inspect}", *args)
+          answers = answer_set.join(", ")
+          answer = ask_simply("#{statement} [#{answers}]", color, options)
           correct_answer = answer_set.include?(answer) ? answer : nil
-          answers = answer_set.map(&:inspect).join(", ")
           say("Your response must be one of: [#{answers}]. Please try again.") unless correct_answer
         end
         correct_answer

data/lib/bundler/vendor/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.
         #
@@ -112,15 +116,15 @@ class Thor
 
         def output_diff_line(diff) #:nodoc:
           case diff.action
-            when '-'
-              say "- #{diff.old_element.chomp}", :red, true
-            when '+'
-              say "+ #{diff.new_element.chomp}", :green, true
-            when '!'
-              say "- #{diff.old_element.chomp}", :red, true
-              say "+ #{diff.new_element.chomp}", :green, true
-            else
-              say "  #{diff.old_element.chomp}", nil, true
+          when '-'
+            say "- #{diff.old_element.chomp}", :red, true
+          when '+'
+            say "+ #{diff.new_element.chomp}", :green, true
+          when '!'
+            say "- #{diff.old_element.chomp}", :red, true
+            say "+ #{diff.new_element.chomp}", :green, true
+          else
+            say "  #{diff.old_element.chomp}", nil, true
           end
         end
 

data/lib/bundler/vendor/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.
         #
@@ -91,15 +95,15 @@ class Thor
 
         def output_diff_line(diff) #:nodoc:
           case diff.action
-            when '-'
-              say "- #{diff.old_element.chomp}", :red, true
-            when '+'
-              say "+ #{diff.new_element.chomp}", :green, true
-            when '!'
-              say "- #{diff.old_element.chomp}", :red, true
-              say "+ #{diff.new_element.chomp}", :green, true
-            else
-              say "  #{diff.old_element.chomp}", nil, true
+          when '-'
+            say "- #{diff.old_element.chomp}", :red, true
+          when '+'
+            say "+ #{diff.new_element.chomp}", :green, true
+          when '!'
+            say "- #{diff.old_element.chomp}", :red, true
+            say "+ #{diff.new_element.chomp}", :green, true
+          else
+            say "  #{diff.old_element.chomp}", nil, true
           end
         end
 

data/lib/bundler/vendor/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