rubygems-update 2.6.4 → 2.6.5

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

@@ -0,0 +1,149 @@
+require "bundler/vendor/thor/lib/thor/shell/basic"
+
+class Bundler::Thor
+  module Shell
+    # Inherit from Bundler::Thor::Shell::Basic and add set_color behavior. Check
+    # Bundler::Thor::Shell::Basic to see all available methods.
+    #
+    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"
+
+      # Set color by using a string or one of the defined constants. If a third
+      # option is set to true, it also adds bold to the string. This is based
+      # on Highline implementation and it automatically appends CLEAR to the end
+      # of the returned String.
+      #
+      # Pass foreground, background and bold options to this method as
+      # symbols.
+      #
+      # Example:
+      #
+      #   set_color "Hi!", :red, :on_white, :bold
+      #
+      # The available colors are:
+      #
+      #   :bold
+      #   :black
+      #   :red
+      #   :green
+      #   :yellow
+      #   :blue
+      #   :magenta
+      #   :cyan
+      #   :white
+      #   :on_black
+      #   :on_red
+      #   :on_green
+      #   :on_yellow
+      #   :on_blue
+      #   :on_magenta
+      #   :on_cyan
+      #   :on_white
+      def set_color(string, *colors)
+        if colors.compact.empty? || !can_display_colors?
+          string
+        elsif colors.all? { |color| color.is_a?(Symbol) || color.is_a?(String) }
+          ansi_colors = colors.map { |color| lookup_color(color) }
+          "#{ansi_colors.join}#{string}#{CLEAR}"
+        else
+          # The old API was `set_color(color, bold=boolean)`. We
+          # continue to support the old API because you should never
+          # break old APIs unnecessarily :P
+          foreground, bold = colors
+          foreground = self.class.const_get(foreground.to_s.upcase) if foreground.is_a?(Symbol)
+
+          bold       = bold ? BOLD : ""
+          "#{bold}#{foreground}#{string}#{CLEAR}"
+        end
+      end
+
+    protected
+
+      def can_display_colors?
+        stdout.tty?
+      end
+
+      # Overwrite show_diff to show diff with colors if Diff::LCS is
+      # available.
+      #
+      def show_diff(destination, content) #:nodoc:
+        if diff_lcs_loaded? && ENV["THOR_DIFF"].nil? && ENV["RAILS_DIFF"].nil?
+          actual  = File.binread(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) #: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
+        end
+      end
+
+      # Check if Diff::LCS is loaded. If it is, use it to create pretty output
+      # for diff.
+      #
+      def diff_lcs_loaded? #:nodoc:
+        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/bundler/lib/bundler/vendor/thor/lib/thor/shell/html.rb

@@ -0,0 +1,126 @@
+require "bundler/vendor/thor/lib/thor/shell/basic"
+
+class Bundler::Thor
+  module Shell
+    # Inherit from Bundler::Thor::Shell::Basic and add set_color behavior. Check
+    # Bundler::Thor::Shell::Basic to see all available methods.
+    #
+    class HTML < Basic
+      # The start of an HTML bold sequence.
+      BOLD       = "font-weight: bold"
+
+      # Set the terminal's foreground HTML color to black.
+      BLACK      = "color: black"
+      # Set the terminal's foreground HTML color to red.
+      RED        = "color: red"
+      # Set the terminal's foreground HTML color to green.
+      GREEN      = "color: green"
+      # Set the terminal's foreground HTML color to yellow.
+      YELLOW     = "color: yellow"
+      # Set the terminal's foreground HTML color to blue.
+      BLUE       = "color: blue"
+      # Set the terminal's foreground HTML color to magenta.
+      MAGENTA    = "color: magenta"
+      # Set the terminal's foreground HTML color to cyan.
+      CYAN       = "color: cyan"
+      # Set the terminal's foreground HTML color to white.
+      WHITE      = "color: white"
+
+      # Set the terminal's background HTML color to black.
+      ON_BLACK   = "background-color: black"
+      # Set the terminal's background HTML color to red.
+      ON_RED     = "background-color: red"
+      # Set the terminal's background HTML color to green.
+      ON_GREEN   = "background-color: green"
+      # Set the terminal's background HTML color to yellow.
+      ON_YELLOW  = "background-color: yellow"
+      # Set the terminal's background HTML color to blue.
+      ON_BLUE    = "background-color: blue"
+      # Set the terminal's background HTML color to magenta.
+      ON_MAGENTA = "background-color: magenta"
+      # Set the terminal's background HTML color to cyan.
+      ON_CYAN    = "background-color: cyan"
+      # Set the terminal's background HTML color to white.
+      ON_WHITE   = "background-color: white"
+
+      # Set color by using a string or one of the defined constants. If a third
+      # option is set to true, it also adds bold to the string. This is based
+      # on Highline implementation and it automatically appends CLEAR to the end
+      # of the returned String.
+      #
+      def set_color(string, *colors)
+        if colors.all? { |color| color.is_a?(Symbol) || color.is_a?(String) }
+          html_colors = colors.map { |color| lookup_color(color) }
+          "<span style=\"#{html_colors.join("; ")};\">#{string}</span>"
+        else
+          color, bold = colors
+          html_color = self.class.const_get(color.to_s.upcase) if color.is_a?(Symbol)
+          styles = [html_color]
+          styles << BOLD if bold
+          "<span style=\"#{styles.join("; ")};\">#{string}</span>"
+        end
+      end
+
+      # Ask something to the user and receives a response.
+      #
+      # ==== Example
+      # ask("What is your name?")
+      #
+      # TODO: Implement #ask for Bundler::Thor::Shell::HTML
+      def ask(statement, color = nil)
+        fail NotImplementedError, "Implement #ask for Bundler::Thor::Shell::HTML"
+      end
+
+    protected
+
+      def can_display_colors?
+        true
+      end
+
+      # Overwrite show_diff to show diff with colors if Diff::LCS is
+      # available.
+      #
+      def show_diff(destination, content) #:nodoc:
+        if diff_lcs_loaded? && ENV["THOR_DIFF"].nil? && ENV["RAILS_DIFF"].nil?
+          actual  = File.binread(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) #: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
+        end
+      end
+
+      # Check if Diff::LCS is loaded. If it is, use it to create pretty output
+      # for diff.
+      #
+      def diff_lcs_loaded? #:nodoc:
+        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/bundler/lib/bundler/vendor/thor/lib/thor/util.rb

@@ -0,0 +1,267 @@
+require "rbconfig"
+
+class Bundler::Thor
+  module Sandbox #:nodoc:
+  end
+
+  # This module holds several utilities:
+  #
+  # 1) Methods to convert thor namespaces to constants and vice-versa.
+  #
+  #   Bundler::Thor::Util.namespace_from_thor_class(Foo::Bar::Baz) #=> "foo:bar:baz"
+  #
+  # 2) Loading thor files and sandboxing:
+  #
+  #   Bundler::Thor::Util.load_thorfile("~/.thor/foo")
+  #
+  module Util
+    class << self
+      # Receives a namespace and search for it in the Bundler::Thor::Base subclasses.
+      #
+      # ==== Parameters
+      # namespace<String>:: The namespace to search for.
+      #
+      def find_by_namespace(namespace)
+        namespace = "default#{namespace}" if namespace.empty? || namespace =~ /^:/
+        Bundler::Thor::Base.subclasses.detect { |klass| klass.namespace == namespace }
+      end
+
+      # Receives a constant and converts it to a Bundler::Thor namespace. Since Bundler::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 Bundler::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(/^Bundler::Thor::Sandbox::/, "")
+        constant = snake_case(constant).squeeze(":")
+        constant
+      end
+
+      # 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 = Bundler::Thor::Base.subclasses.dup
+        Bundler::Thor::Base.subclasses.clear
+
+        load_thorfile(file, contents)
+
+        new_constants = Bundler::Thor::Base.subclasses.dup
+        Bundler::Thor::Base.subclasses.replace(old_constants)
+
+        new_constants.map! { |c| c.namespace }
+        new_constants.compact!
+        new_constants
+      end
+
+      # Returns the thor classes declared inside the given class.
+      #
+      def thor_classes_in(klass)
+        stringfied_constants = klass.constants.map { |c| c.to_s }
+        Bundler::Thor::Base.subclasses.select do |subclass|
+          next unless subclass.name
+          stringfied_constants.include?(subclass.name.gsub("#{klass.name}::", ""))
+        end
+      end
+
+      # 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("_") =~ /_*(.*)/
+        $+.downcase
+      end
+
+      # 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
+
+      # Receives a namespace and tries to retrieve a Bundler::Thor or Bundler::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 < Bundler::Thor
+      #     def baz
+      #     end
+      #   end
+      #
+      #   class Baz::Foo < Bundler::Thor::Group
+      #   end
+      #
+      #   Bundler::Thor::Util.namespace_to_thor_class("foo:bar")     #=> Foo::Bar, nil # will invoke default command
+      #   Bundler::Thor::Util.namespace_to_thor_class("baz:foo")     #=> Baz::Foo, nil
+      #   Bundler::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   = Bundler::Thor::Util.find_by_namespace(pieces.join(":"))
+        end
+        unless klass # look for a Bundler::Thor::Group with the right name
+          klass, command = Bundler::Thor::Util.find_by_namespace(namespace), nil
+        end
+        if !klass && fallback # try a command in the default namespace
+          command = namespace
+          klass   = Bundler::Thor::Util.find_by_namespace("")
+        end
+        [klass, command]
+      end
+      alias_method :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)
+
+        begin
+          Bundler::Thor::Sandbox.class_eval(content, path)
+        rescue StandardError => 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
+
+      def user_home # rubocop:disable MethodLength
+        @@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 thor_root_glob
+        files = Dir["#{escape_globs(thor_root)}/*"]
+
+        files.map! do |file|
+          File.directory?(file) ? File.join(file, "main.thor") : file
+        end
+      end
+
+      # Where to look for Bundler::Thor files.
+      #
+      def globs_for(path)
+        path = escape_globs(path)
+        ["#{path}/Bundler::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 ruby_command # rubocop:disable MethodLength
+        @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"]
+
+              # 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
+              end
+            rescue NotImplementedError # rubocop:disable HandleExceptions
+              # just ignore on windows
+            end
+          end
+
+          # escape string in case path to ruby executable contain spaces.
+          ruby.sub!(/.*\s.*/m, '"\&"')
+          ruby
+        end
+      end
+
+      # Returns a string that has had any glob characters escaped.
+      # The glob characters are `* ? { } [ ]`.
+      #
+      # ==== Examples
+      #
+      #   Bundler::Thor::Util.escape_globs('[apps]')   # => '\[apps\]'
+      #
+      # ==== Parameters
+      # String
+      #
+      # ==== Returns
+      # String
+      #
+      def escape_globs(path)
+        path.to_s.gsub(/[*?{}\[\]]/, '\\\\\\&')
+      end
+    end
+  end
+end