@ai-ecoverse/wasix-ruby 3.4.11-3 → 3.4.11-4

package/lib/ruby/3.4.11/bundler/vendor/thor/lib/thor/shell/table_printer.rb

@@ -1,118 +0,0 @@
-require_relative "column_printer"
-require_relative "terminal"
-
-class Bundler::Thor
-  module Shell
-    class TablePrinter < ColumnPrinter
-      BORDER_SEPARATOR = :separator
-
-      def initialize(stdout, options = {})
-        super
-        @formats = []
-        @maximas = []
-        @colwidth = options[:colwidth]
-        @truncate = options[:truncate] == true ? Terminal.terminal_width : options[:truncate]
-        @padding = 1
-      end
-
-      def print(array)
-        return if array.empty?
-
-        prepare(array)
-
-        print_border_separator if options[:borders]
-
-        array.each do |row|
-          if options[:borders] && row == BORDER_SEPARATOR
-            print_border_separator
-            next
-          end
-
-          sentence = "".dup
-
-          row.each_with_index do |column, index|
-            sentence << format_cell(column, row.size, index)
-          end
-
-          sentence = truncate(sentence)
-          sentence << "|" if options[:borders]
-          stdout.puts indentation + sentence
-
-        end
-        print_border_separator if options[:borders]
-      end
-
-    private
-
-      def prepare(array)
-        array = array.reject{|row| row == BORDER_SEPARATOR }
-
-        @formats << "%-#{@colwidth + 2}s".dup if @colwidth
-        start = @colwidth ? 1 : 0
-
-        colcount = array.max { |a, b| a.size <=> b.size }.size
-
-        start.upto(colcount - 1) do |index|
-          maxima = array.map { |row| row[index] ? row[index].to_s.size : 0 }.max
-
-          @maximas << maxima
-          @formats << if options[:borders]
-             "%-#{maxima}s".dup
-          elsif index == colcount - 1
-            # Don't output 2 trailing spaces when printing the last column
-            "%-s".dup
-          else
-            "%-#{maxima + 2}s".dup
-          end
-        end
-
-        @formats << "%s"
-      end
-
-      def format_cell(column, row_size, index)
-        maxima = @maximas[index]
-
-        f = if column.is_a?(Numeric)
-          if options[:borders]
-            # With borders we handle padding separately
-            "%#{maxima}s"
-          elsif index == row_size - 1
-            # Don't output 2 trailing spaces when printing the last column
-            "%#{maxima}s"
-          else
-            "%#{maxima}s  "
-          end
-        else
-          @formats[index]
-        end
-
-        cell = "".dup
-        cell << "|" + " " * @padding if options[:borders]
-        cell << f % column.to_s
-        cell << " " * @padding if options[:borders]
-        cell
-      end
-
-      def print_border_separator
-        separator = @maximas.map do |maxima|
-          "+" + "-" * (maxima + 2 * @padding)
-        end
-        stdout.puts indentation + separator.join + "+"
-      end
-
-      def truncate(string)
-        return string unless @truncate
-        chars = string.chars.to_a
-        if chars.length <= @truncate
-          chars.join
-        else
-          chars[0, @truncate - 3 - @indent].join + "..."
-        end
-      end
-
-      def indentation
-        " " * @indent
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/vendor/thor/lib/thor/shell/terminal.rb

@@ -1,42 +0,0 @@
-class Bundler::Thor
-  module Shell
-    module Terminal
-      DEFAULT_TERMINAL_WIDTH = 80
-
-      class << self
-        # This code was copied from Rake, available under MIT-LICENSE
-        # Copyright (c) 2003, 2004 Jim Weirich
-        def terminal_width
-          result = if ENV["THOR_COLUMNS"]
-            ENV["THOR_COLUMNS"].to_i
-          else
-            unix? ? dynamic_width : DEFAULT_TERMINAL_WIDTH
-          end
-          result < 10 ? DEFAULT_TERMINAL_WIDTH : result
-        rescue
-          DEFAULT_TERMINAL_WIDTH
-        end
-
-        def unix?
-          RUBY_PLATFORM =~ /(aix|darwin|linux|(net|free|open)bsd|cygwin|solaris)/i
-        end
-
-      private
-
-        # Calculate the dynamic width of the terminal
-        def dynamic_width
-          @dynamic_width ||= (dynamic_width_stty.nonzero? || dynamic_width_tput)
-        end
-
-        def dynamic_width_stty
-          `stty size 2>/dev/null`.split[1].to_i
-        end
-
-        def dynamic_width_tput
-          `tput cols 2>/dev/null`.to_i
-        end
-
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/vendor/thor/lib/thor/shell/wrapped_printer.rb

@@ -1,38 +0,0 @@
-require_relative "column_printer"
-require_relative "terminal"
-
-class Bundler::Thor
-  module Shell
-    class WrappedPrinter < ColumnPrinter
-      def print(message)
-        width = Terminal.terminal_width - @indent
-        paras = message.split("\n\n")
-
-        paras.map! do |unwrapped|
-          words = unwrapped.split(" ")
-          counter = words.first.length
-          words.inject do |memo, word|
-            word = word.gsub(/\n\005/, "\n").gsub(/\005/, "\n")
-            counter = 0 if word.include? "\n"
-            if (counter + word.length + 1) < width
-              memo = "#{memo} #{word}"
-              counter += (word.length + 1)
-            else
-              memo = "#{memo}\n#{word}"
-              counter = word.length
-            end
-            memo
-          end
-        end.compact!
-
-        paras.each do |para|
-          para.split("\n").each do |line|
-            stdout.puts line.insert(0, " " * @indent)
-          end
-          stdout.puts unless para == paras.last
-        end
-      end
-    end
-  end
-end
-

package/lib/ruby/3.4.11/bundler/vendor/thor/lib/thor/shell.rb

@@ -1,81 +0,0 @@
-require "rbconfig"
-
-class Bundler::Thor
-  module Base
-    class << self
-      attr_writer :shell
-
-      # Returns the shell used in all Bundler::Thor classes. If you are in a Unix platform
-      # it will use a colored log, otherwise it will use a basic one without color.
-      #
-      def shell
-        @shell ||= if ENV["THOR_SHELL"] && !ENV["THOR_SHELL"].empty?
-          Bundler::Thor::Shell.const_get(ENV["THOR_SHELL"])
-        elsif RbConfig::CONFIG["host_os"] =~ /mswin|mingw/ && !ENV["ANSICON"]
-          Bundler::Thor::Shell::Basic
-        else
-          Bundler::Thor::Shell::Color
-        end
-      end
-    end
-  end
-
-  module Shell
-    SHELL_DELEGATED_METHODS = [:ask, :error, :set_color, :yes?, :no?, :say, :say_error, :say_status, :print_in_columns, :print_table, :print_wrapped, :file_collision, :terminal_width]
-    attr_writer :shell
-
-    autoload :Basic, File.expand_path("shell/basic", __dir__)
-    autoload :Color, File.expand_path("shell/color", __dir__)
-    autoload :HTML,  File.expand_path("shell/html", __dir__)
-
-    # Add shell to initialize config values.
-    #
-    # ==== Configuration
-    # shell<Object>:: An instance of the shell to be used.
-    #
-    # ==== Examples
-    #
-    #   class MyScript < Bundler::Thor
-    #     argument :first, :type => :numeric
-    #   end
-    #
-    #   MyScript.new [1.0], { :foo => :bar }, :shell => Bundler::Thor::Shell::Basic.new
-    #
-    def initialize(args = [], options = {}, config = {})
-      super
-      self.shell = config[:shell]
-      shell.base ||= self if shell.respond_to?(:base)
-    end
-
-    # Holds the shell for the given Bundler::Thor instance. If no shell is given,
-    # it gets a default shell from Bundler::Thor::Base.shell.
-    def shell
-      @shell ||= Bundler::Thor::Base.shell.new
-    end
-
-    # Common methods that are delegated to the shell.
-    SHELL_DELEGATED_METHODS.each do |method|
-      module_eval <<-METHOD, __FILE__, __LINE__ + 1
-        def #{method}(*args,&block)
-          shell.#{method}(*args,&block)
-        end
-      METHOD
-    end
-
-    # Yields the given block with padding.
-    def with_padding
-      shell.padding += 1
-      yield
-    ensure
-      shell.padding -= 1
-    end
-
-  protected
-
-    # Allow shell to be shared between invocations.
-    #
-    def _shared_configuration #:nodoc:
-      super.merge!(shell: shell)
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/vendor/thor/lib/thor/util.rb

@@ -1,285 +0,0 @@
-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 responsible 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!(&: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(&: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("_") =~ /_*(.*)/
-        Regexp.last_match(-1).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(&: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, command  = namespace.split(":")
-          namespace = pieces.join(":")
-          namespace = "default" if namespace.empty?
-          klass = Bundler::Thor::Base.subclasses.detect { |thor| thor.namespace == namespace && thor.command_exists?(command) }
-        end
-        unless klass # look for a Bundler::Thor::Group with the right name
-          klass = Bundler::Thor::Util.find_by_namespace(namespace)
-          command = 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.read(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
-        @@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").tr("\\", "/")
-      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}/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
-        @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 Lint/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
-
-      # Returns a string that has had any HTML characters escaped.
-      #
-      # ==== Examples
-      #
-      #   Bundler::Thor::Util.escape_html('<div>')   # => "&lt;div&gt;"
-      #
-      # ==== Parameters
-      # String
-      #
-      # ==== Returns
-      # String
-      #
-      def escape_html(string)
-        CGI.escapeHTML(string)
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/vendor/thor/lib/thor/version.rb

@@ -1,3 +0,0 @@
-class Bundler::Thor
-  VERSION = "1.3.2"
-end