gorails 0.1.2 → 0.1.5

data/vendor/deps/cli-kit/lib/cli/kit/util.rb

@@ -0,0 +1,133 @@
+# typed: true
+require 'cli/kit'
+
+module CLI
+  module Kit
+    module Util
+      class << self
+        extend T::Sig
+        #
+        # Converts an integer representing bytes into a human readable format
+        #
+        sig { params(bytes: Integer, precision: Integer, space: T::Boolean).returns(String) }
+        def to_filesize(bytes, precision: 2, space: false)
+          to_si_scale(bytes, 'B', precision: precision, space: space, factor: 1024)
+        end
+
+        # Converts a number to a human readable format on the SI scale
+        #
+        sig do
+          params(number: Numeric, unit: String, factor: Integer, precision: Integer,
+            space: T::Boolean).returns(String)
+        end
+        def to_si_scale(number, unit = '', factor: 1000, precision: 2, space: false)
+          raise ArgumentError, 'factor should only be 1000 or 1024' unless [1000, 1024].include?(factor)
+
+          small_scale = ['m', 'µ', 'n', 'p', 'f', 'a', 'z', 'y']
+          big_scale = ['k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y']
+          negative = number < 0
+          number = number.abs.to_f
+
+          if number == 0.0 || number.between?(1, factor)
+            prefix = ''
+            scale = 0
+          else
+            scale = Math.log(number, factor).floor
+            if number < 1
+              index = [-scale - 1, small_scale.length].min
+              scale = -(index + 1)
+              prefix = T.must(small_scale[index])
+            else
+              index = [scale - 1, big_scale.length].min
+              scale = index + 1
+              prefix = T.must(big_scale[index])
+            end
+          end
+
+          divider = (factor**scale)
+          fnum = (number / divider.to_f).round(precision)
+
+          # Trim useless decimal
+          fnum = fnum.to_i if (fnum.to_i.to_f * divider.to_f) == number
+
+          fnum = -fnum if negative
+          if space
+            prefix = ' ' + prefix
+          end
+
+          "#{fnum}#{prefix}#{unit}"
+        end
+
+        # Dir.chdir, when invoked in block form, complains when we call chdir
+        # again recursively. There's no apparent good reason for this, so we
+        # simply implement our own block form of Dir.chdir here.
+        sig do
+          type_parameters(:T).params(dir: String, block: T.proc.returns(T.type_parameter(:T)))
+            .returns(T.type_parameter(:T))
+        end
+        def with_dir(dir, &block)
+          prev = Dir.pwd
+          begin
+            Dir.chdir(dir)
+            yield
+          ensure
+            Dir.chdir(prev)
+          end
+        end
+
+        # Must call retry_after on the result in order to execute the block
+        #
+        # Example usage:
+        #
+        # CLI::Kit::Util.begin do
+        #   might_raise_if_costly_prep_not_done()
+        # end.retry_after(ExpectedError) do
+        #   costly_prep()
+        # end
+        sig do
+          type_parameters(:T).params(block_that_might_raise: T.proc.returns(T.type_parameter(:T)))
+            .returns(Retrier[T.type_parameter(:T)])
+        end
+        def begin(&block_that_might_raise)
+          Retrier.new(block_that_might_raise)
+        end
+      end
+
+      class Retrier
+        extend T::Sig
+        extend T::Generic
+
+        BlockReturnType = type_member
+
+        sig { params(block_that_might_raise: T.proc.returns(BlockReturnType)).void }
+        def initialize(block_that_might_raise)
+          @block_that_might_raise = block_that_might_raise
+        end
+
+        sig do
+          params(
+            exception: T.class_of(Exception),
+            retries: Integer,
+            before_retry: T.nilable(T.proc.params(e: Exception).void)
+          ).returns(BlockReturnType)
+        end
+        def retry_after(exception = StandardError, retries: 1, &before_retry)
+          @block_that_might_raise.call
+        rescue exception => e
+          raise if (retries -= 1) < 0
+
+          if before_retry
+            if before_retry.arity == 0
+              T.cast(before_retry, T.proc.void).call
+            else
+              T.cast(before_retry, T.proc.params(e: Exception).void).call(e)
+            end
+          end
+          retry
+        end
+      end
+
+      private_constant :Retrier
+    end
+  end
+end

data/vendor/deps/cli-kit/lib/cli/kit/version.rb

@@ -0,0 +1,7 @@
+# typed: true
+
+module CLI
+  module Kit
+    VERSION = '4.0.0'
+  end
+end

data/vendor/deps/cli-kit/lib/cli/kit.rb

@@ -0,0 +1,151 @@
+# typed: true
+require 'cli/ui'
+
+unless defined?(T)
+  require('cli/kit/sorbet_runtime_stub')
+end
+
+require 'cli/kit/core_ext'
+
+module CLI
+  module Kit
+    extend T::Sig
+
+    autoload :Args,            'cli/kit/args'
+    autoload :BaseCommand,     'cli/kit/base_command'
+    autoload :CommandRegistry, 'cli/kit/command_registry'
+    autoload :CommandHelp,     'cli/kit/command_help'
+    autoload :Config,          'cli/kit/config'
+    autoload :ErrorHandler,    'cli/kit/error_handler'
+    autoload :Executor,        'cli/kit/executor'
+    autoload :Ini,             'cli/kit/ini'
+    autoload :Levenshtein,     'cli/kit/levenshtein'
+    autoload :Logger,          'cli/kit/logger'
+    autoload :Opts,            'cli/kit/opts'
+    autoload :Resolver,        'cli/kit/resolver'
+    autoload :Support,         'cli/kit/support'
+    autoload :System,          'cli/kit/system'
+    autoload :Util,            'cli/kit/util'
+
+    EXIT_FAILURE_BUT_NOT_BUG = 30
+    EXIT_BUG                 = 1
+    EXIT_SUCCESS             = 0
+
+    # Abort, Bug, AbortSilent, and BugSilent are four ways of immediately bailing
+    # on command-line execution when an unrecoverable error occurs.
+    #
+    # Note that these don't inherit from StandardError, and so are not caught by
+    # a bare `rescue => e`.
+    #
+    # * Abort prints its message in red and exits 1;
+    # * Bug additionally submits the exception to the exception_reporter passed to
+    #     `CLI::Kit::ErrorHandler.new`
+    # * AbortSilent and BugSilent do the same as above, but do not print
+    #     messages before exiting.
+    #
+    # Treat these like panic() in Go:
+    #   * Don't rescue them. Use a different Exception class if you plan to recover;
+    #   * Provide a useful message, since it will be presented in brief to the
+    #       user, and will be useful for debugging.
+    #   * Avoid using it if it does actually make sense to recover from an error.
+    #
+    # Additionally:
+    #   * Do not subclass these.
+    #   * Only use AbortSilent or BugSilent if you prefer to print a more
+    #       contextualized error than Abort or Bug would present to the user.
+    #   * In general, don't attach a message to AbortSilent or BugSilent.
+    #   * Never raise GenericAbort directly.
+    #   * Think carefully about whether Abort or Bug is more appropriate. Is this
+    #       a bug in the tool? Or is it just user error, transient network
+    #       failure, etc.?
+    #   * One case where it's ok to rescue (cli-kit internals or tests aside):
+    #       1. rescue Abort or Bug
+    #       2. Print a contextualized error message
+    #       3. Re-raise AbortSilent or BugSilent respectively.
+    #
+    # These aren't the only exceptions that can carry this 'bug' and 'silent'
+    # metadata, however:
+    #
+    # If you raise an exception with `CLI::Kit.raise(..., bug: x, silent: y)`,
+    # those last two (optional) keyword arguments will attach the metadata to
+    # whatever exception you raise. This is interpreted later in the
+    # ErrorHandler to decide how to print output and whether to submit the
+    # exception to bugsnag.
+    GenericAbort = Class.new(Exception) # rubocop:disable Lint/InheritException
+
+    class Abort < GenericAbort # bug:false; silent: false
+      extend(T::Sig)
+
+      sig { returns(T::Boolean) }
+      def bug?
+        false
+      end
+    end
+
+    class Bug < GenericAbort # bug:true; silent:false
+    end
+
+    class BugSilent < GenericAbort # bug:true; silent:true
+      extend(T::Sig)
+
+      sig { returns(T::Boolean) }
+      def silent?
+        true
+      end
+    end
+
+    class AbortSilent < GenericAbort # bug:false; silent:true
+      extend(T::Sig)
+
+      sig { returns(T::Boolean) }
+      def bug?
+        false
+      end
+
+      sig { returns(T::Boolean) }
+      def silent?
+        true
+      end
+    end
+
+    # Mirrors the API of Kernel#raise, but with the addition of a few new
+    # optional keyword arguments. `bug` and `silent` attach metadata to the
+    # exception being raised, which is interpreted later in the ErrorHandler to
+    # decide what to print and whether to submit to bugsnag.
+    #
+    # `depth` is used to trim leading elements of the backtrace. If you wrap
+    # this method in your own wrapper, you'll want to pass `depth: 2`, for
+    # example.
+    sig do
+      params(
+        exception: T.any(Class, String, Exception),
+        string: T.untyped,
+        array: T.nilable(T::Array[String]),
+        cause: T.nilable(Exception),
+        bug: T.nilable(T::Boolean),
+        silent: T.nilable(T::Boolean),
+        depth: Integer,
+      ).returns(T.noreturn)
+    end
+    def self.raise(
+      # default arguments
+      exception = T.unsafe(nil), string = T.unsafe(nil), array = T.unsafe(nil), cause: $ERROR_INFO,
+      # new arguments
+      bug: nil, silent: nil, depth: 1
+    )
+      if array
+        T.unsafe(Kernel).raise(exception, string, array, cause: cause)
+      elsif string
+        T.unsafe(Kernel).raise(exception, string, Kernel.caller(depth), cause: cause)
+      elsif exception.is_a?(String)
+        T.unsafe(Kernel).raise(RuntimeError, exception, Kernel.caller(depth), cause: cause)
+      else
+        T.unsafe(Kernel).raise(exception, exception.message, Kernel.caller(depth), cause: cause)
+      end
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      e.bug!(bug) unless bug.nil?
+      e.silent!(silent) unless silent.nil?
+      Kernel.raise(e, cause: cause)
+    end
+  end
+end

data/vendor/deps/cli-ui/REVISION

@@ -0,0 +1 @@
+c9b77b8073f9242ba8d0c8c5651264810b23cb0d

data/vendor/deps/cli-ui/lib/cli/ui/ansi.rb

@@ -0,0 +1,180 @@
+# typed: true
+require 'cli/ui'
+
+module CLI
+  module UI
+    module ANSI
+      extend T::Sig
+
+      ESC = "\x1b"
+
+      # ANSI escape sequences (like \x1b[31m) have zero width.
+      # when calculating the padding width, we must exclude them.
+      # This also implements a basic version of utf8 character width calculation like
+      # we could get for real from something like utf8proc.
+      #
+      sig { params(str: String).returns(Integer) }
+      def self.printing_width(str)
+        zwj = T.let(false, T::Boolean)
+        strip_codes(str).codepoints.reduce(0) do |acc, cp|
+          if zwj
+            zwj = false
+            next acc
+          end
+          case cp
+          when 0x200d # zero-width joiner
+            zwj = true
+            acc
+          when "\n"
+            acc
+          else
+            acc + 1
+          end
+        end
+      end
+
+      # Strips ANSI codes from a str
+      #
+      # ==== Attributes
+      #
+      # - +str+ - The string from which to strip codes
+      #
+      sig { params(str: String).returns(String) }
+      def self.strip_codes(str)
+        str.gsub(/\x1b\[[\d;]+[A-z]|\r/, '')
+      end
+
+      # Returns an ANSI control sequence
+      #
+      # ==== Attributes
+      #
+      # - +args+ - Argument to pass to the ANSI control sequence
+      # - +cmd+ - ANSI control sequence Command
+      #
+      sig { params(args: String, cmd: String).returns(String) }
+      def self.control(args, cmd)
+        ESC + '[' + args + cmd
+      end
+
+      # https://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+      sig { params(params: String).returns(String) }
+      def self.sgr(params)
+        control(params, 'm')
+      end
+
+      # Cursor Movement
+
+      # Move the cursor up n lines
+      #
+      # ==== Attributes
+      #
+      # * +n+ - number of lines by which to move the cursor up
+      #
+      sig { params(n: Integer).returns(String) }
+      def self.cursor_up(n = 1)
+        return '' if n.zero?
+
+        control(n.to_s, 'A')
+      end
+
+      # Move the cursor down n lines
+      #
+      # ==== Attributes
+      #
+      # * +n+ - number of lines by which to move the cursor down
+      #
+      sig { params(n: Integer).returns(String) }
+      def self.cursor_down(n = 1)
+        return '' if n.zero?
+
+        control(n.to_s, 'B')
+      end
+
+      # Move the cursor forward n columns
+      #
+      # ==== Attributes
+      #
+      # * +n+ - number of columns by which to move the cursor forward
+      #
+      sig { params(n: Integer).returns(String) }
+      def self.cursor_forward(n = 1)
+        return '' if n.zero?
+
+        control(n.to_s, 'C')
+      end
+
+      # Move the cursor back n columns
+      #
+      # ==== Attributes
+      #
+      # * +n+ - number of columns by which to move the cursor back
+      #
+      sig { params(n: Integer).returns(String) }
+      def self.cursor_back(n = 1)
+        return '' if n.zero?
+
+        control(n.to_s, 'D')
+      end
+
+      # Move the cursor to a specific column
+      #
+      # ==== Attributes
+      #
+      # * +n+ - The column to move to
+      #
+      sig { params(n: Integer).returns(String) }
+      def self.cursor_horizontal_absolute(n = 1)
+        cmd = control(n.to_s, 'G')
+        cmd += cursor_back if CLI::UI::OS.current.shift_cursor_back_on_horizontal_absolute?
+        cmd
+      end
+
+      # Show the cursor
+      #
+      sig { returns(String) }
+      def self.show_cursor
+        control('', '?25h')
+      end
+
+      # Hide the cursor
+      #
+      sig { returns(String) }
+      def self.hide_cursor
+        control('', '?25l')
+      end
+
+      # Save the cursor position
+      #
+      sig { returns(String) }
+      def self.cursor_save
+        control('', 's')
+      end
+
+      # Restore the saved cursor position
+      #
+      sig { returns(String) }
+      def self.cursor_restore
+        control('', 'u')
+      end
+
+      # Move to the next line
+      #
+      sig { returns(String) }
+      def self.next_line
+        cursor_down + cursor_horizontal_absolute
+      end
+
+      # Move to the previous line
+      #
+      sig { returns(String) }
+      def self.previous_line
+        cursor_up + cursor_horizontal_absolute
+      end
+
+      sig { returns(String) }
+      def self.clear_to_end_of_line
+        control('', 'K')
+      end
+    end
+  end
+end

data/vendor/deps/cli-ui/lib/cli/ui/color.rb

@@ -0,0 +1,98 @@
+# typed: true
+require 'cli/ui'
+
+module CLI
+  module UI
+    class Color
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :sgr, :code
+
+      sig { returns(Symbol) }
+      attr_reader :name
+
+      # Creates a new color mapping
+      # Signatures can be found here:
+      # https://en.wikipedia.org/wiki/ANSI_escape_code#Colors
+      #
+      # ==== Attributes
+      #
+      # * +sgr+ - The color signature
+      # * +name+ - The name of the color
+      #
+      sig { params(sgr: String, name: Symbol).void }
+      def initialize(sgr, name)
+        @sgr  = sgr
+        @code = CLI::UI::ANSI.sgr(sgr)
+        @name = name
+      end
+
+      RED     = new('31', :red)
+      GREEN   = new('32', :green)
+      YELLOW  = new('33', :yellow)
+      # default blue is low-contrast against black in some default terminal color scheme
+      BLUE    = new('94', :blue) # 9x = high-intensity fg color x
+      MAGENTA = new('35', :magenta)
+      CYAN    = new('36', :cyan)
+      RESET   = new('0',  :reset)
+      BOLD    = new('1',  :bold)
+      WHITE   = new('97', :white)
+
+      # 240 is very dark gray; 255 is very light gray. 244 is somewhat dark.
+      GRAY = new('38;5;244', :grey)
+
+      MAP = {
+        red: RED,
+        green: GREEN,
+        yellow: YELLOW,
+        blue: BLUE,
+        magenta: MAGENTA,
+        cyan: CYAN,
+        reset: RESET,
+        bold: BOLD,
+        gray: GRAY,
+      }.freeze
+
+      class InvalidColorName < ArgumentError
+        extend T::Sig
+
+        sig { params(name: Symbol).void }
+        def initialize(name)
+          super
+          @name = name
+        end
+
+        sig { returns(String) }
+        def message
+          keys = Color.available.map(&:inspect).join(',')
+          "invalid color: #{@name.inspect} " \
+            "-- must be one of CLI::UI::Color.available (#{keys})"
+        end
+      end
+
+      # Looks up a color code by name
+      #
+      # ==== Raises
+      # Raises a InvalidColorName if the color is not available
+      # You likely need to add it to the +MAP+ or you made a typo
+      #
+      # ==== Returns
+      # Returns a color code
+      #
+      sig { params(name: T.any(Symbol, String)).returns(Color) }
+      def self.lookup(name)
+        MAP.fetch(name.to_sym)
+      rescue KeyError
+        raise InvalidColorName, name
+      end
+
+      # All available colors by name
+      #
+      sig { returns(T::Array[Symbol]) }
+      def self.available
+        MAP.keys
+      end
+    end
+  end
+end