es_cli 0.1.0

data/vendor/bundle/ruby/3.1.0/gems/thor-1.3.2/lib/thor/shell/table_printer.rb

@@ -0,0 +1,118 @@
+require_relative "column_printer"
+require_relative "terminal"
+
+class 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

data/vendor/bundle/ruby/3.1.0/gems/thor-1.3.2/lib/thor/shell/terminal.rb

@@ -0,0 +1,42 @@
+class 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

data/vendor/bundle/ruby/3.1.0/gems/thor-1.3.2/lib/thor/shell/wrapped_printer.rb

@@ -0,0 +1,38 @@
+require_relative "column_printer"
+require_relative "terminal"
+
+class 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
+

data/vendor/bundle/ruby/3.1.0/gems/thor-1.3.2/lib/thor/shell.rb

@@ -0,0 +1,81 @@
+require "rbconfig"
+
+class Thor
+  module Base
+    class << self
+      attr_writer :shell
+
+      # Returns the shell used in all 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?
+          Thor::Shell.const_get(ENV["THOR_SHELL"])
+        elsif RbConfig::CONFIG["host_os"] =~ /mswin|mingw/ && !ENV["ANSICON"]
+          Thor::Shell::Basic
+        else
+          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 < 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]
+      shell.base ||= self if 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
+
+    # 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

data/vendor/bundle/ruby/3.1.0/gems/thor-1.3.2/lib/thor/util.rb

@@ -0,0 +1,285 @@
+require "rbconfig"
+
+class Thor
+  module Sandbox #:nodoc:
+  end
+
+  # This module holds several utilities:
+  #
+  # 1) Methods to convert thor namespaces to constants and vice-versa.
+  #
+  #   Thor::Util.namespace_from_thor_class(Foo::Bar::Baz) #=> "foo:bar:baz"
+  #
+  # 2) Loading thor files and sandboxing:
+  #
+  #   Thor::Util.load_thorfile("~/.thor/foo")
+  #
+  module Util
+    class << self
+      # 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.detect { |klass| klass.namespace == namespace }
+      end
+
+      # Receives a constant and converts it to a Thor namespace. Since 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 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
+
+      # 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
+
+        load_thorfile(file, contents)
+
+        new_constants = Thor::Base.subclasses.dup
+        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)
+        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 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, command  = namespace.split(":")
+          namespace = pieces.join(":")
+          namespace = "default" if namespace.empty?
+          klass = Thor::Base.subclasses.detect { |thor| thor.namespace == namespace && thor.command_exists?(command) }
+        end
+        unless klass # look for a Thor::Group with the right name
+          klass = Thor::Util.find_by_namespace(namespace)
+          command = nil
+        end
+        if !klass && fallback # try a command in the default namespace
+          command = namespace
+          klass   = 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
+          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 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
+      #
+      #   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
+      #
+      #   Thor::Util.escape_html('<div>')   # => "&lt;div&gt;"
+      #
+      # ==== Parameters
+      # String
+      #
+      # ==== Returns
+      # String
+      #
+      def escape_html(string)
+        CGI.escapeHTML(string)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/thor-1.3.2/lib/thor/version.rb

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