hank 0.1.0

data/sorbet/rbi/annotations/rainbow.rbi

@@ -0,0 +1,269 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module Rainbow
+  # @shim: https://github.com/sickill/rainbow/blob/master/lib/rainbow.rb#L10-L12
+  sig { returns(T::Boolean) }
+  attr_accessor :enabled
+
+  class Color
+    sig { returns(Symbol) }
+    attr_reader :ground
+
+    sig { params(ground: Symbol, values: T.any([Integer], [Integer, Integer, Integer])).returns(Color) }
+    def self.build(ground, values); end
+
+    sig { params(hex: String).returns([Integer, Integer, Integer]) }
+    def self.parse_hex_color(hex); end
+
+    class Indexed < Rainbow::Color
+      sig { returns(Integer) }
+      attr_reader :num
+
+      sig { params(ground: Symbol, num: Integer).void }
+      def initialize(ground, num); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+    end
+
+    class Named < Rainbow::Color::Indexed
+      NAMES = T.let(nil, T::Hash[Symbol, Integer])
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+    end
+
+    class RGB < Rainbow::Color::Indexed
+      sig { returns(Integer) }
+      attr_reader :r, :g, :b
+
+      sig { params(ground: Symbol, values: Integer).void }
+      def initialize(ground, *values); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+
+      sig { params(value: Numeric).returns(Integer) }
+      def self.to_ansi_domain(value); end
+    end
+
+    class X11Named < Rainbow::Color::RGB
+      include Rainbow::X11ColorNames
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+    end
+  end
+
+  sig { returns(Wrapper) }
+  def self.global; end
+
+  sig { returns(T::Boolean) }
+  def self.enabled; end
+
+  sig { params(value: T::Boolean).returns(T::Boolean) }
+  def self.enabled=(value); end
+
+  sig { params(string: String).returns(String) }
+  def self.uncolor(string); end
+
+  class NullPresenter < String
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def bg(*values); end
+
+    sig { returns(NullPresenter) }
+    def reset; end
+
+    sig { returns(NullPresenter) }
+    def bright; end
+
+    sig { returns(NullPresenter) }
+    def faint; end
+
+    sig { returns(NullPresenter) }
+    def italic; end
+
+    sig { returns(NullPresenter) }
+    def underline; end
+
+    sig { returns(NullPresenter) }
+    def blink; end
+
+    sig { returns(NullPresenter) }
+    def inverse; end
+
+    sig { returns(NullPresenter) }
+    def hide; end
+
+    sig { returns(NullPresenter) }
+    def cross_out; end
+
+    sig { returns(NullPresenter) }
+    def black; end
+
+    sig { returns(NullPresenter) }
+    def red; end
+
+    sig { returns(NullPresenter) }
+    def green; end
+
+    sig { returns(NullPresenter) }
+    def yellow; end
+
+    sig { returns(NullPresenter) }
+    def blue; end
+
+    sig { returns(NullPresenter) }
+    def magenta; end
+
+    sig { returns(NullPresenter) }
+    def cyan; end
+
+    sig { returns(NullPresenter) }
+    def white; end
+
+    sig { returns(NullPresenter) }
+    def bold; end
+
+    sig { returns(NullPresenter) }
+    def dark; end
+
+    sig { returns(NullPresenter) }
+    def strike; end
+  end
+
+  class Presenter < String
+    TERM_EFFECTS = T.let(nil, T::Hash[Symbol, Integer])
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def bg(*values); end
+
+    sig { returns(Presenter) }
+    def reset; end
+
+    sig { returns(Presenter) }
+    def bright; end
+
+    sig { returns(Presenter) }
+    def faint; end
+
+    sig { returns(Presenter) }
+    def italic; end
+
+    sig { returns(Presenter) }
+    def underline; end
+
+    sig { returns(Presenter) }
+    def blink; end
+
+    sig { returns(Presenter) }
+    def inverse; end
+
+    sig { returns(Presenter) }
+    def hide; end
+
+    sig { returns(Presenter) }
+    def cross_out; end
+
+    sig { returns(Presenter) }
+    def black; end
+
+    sig { returns(Presenter) }
+    def red; end
+
+    sig { returns(Presenter) }
+    def green; end
+
+    sig { returns(Presenter) }
+    def yellow; end
+
+    sig { returns(Presenter) }
+    def blue; end
+
+    sig { returns(Presenter) }
+    def magenta; end
+
+    sig { returns(Presenter) }
+    def cyan; end
+
+    sig { returns(Presenter) }
+    def white; end
+
+    sig { returns(Presenter) }
+    def bold; end
+
+    sig { returns(Presenter) }
+    def dark; end
+
+    sig { returns(Presenter) }
+    def strike; end
+  end
+
+  class StringUtils
+    sig { params(string: String, codes: T::Array[Integer]).returns(String) }
+    def self.wrap_with_sgr(string, codes); end
+
+    sig { params(string: String).returns(String) }
+    def self.uncolor(string); end
+  end
+
+  VERSION = T.let(nil, String)
+
+  class Wrapper
+    sig { returns(T::Boolean) }
+    attr_accessor :enabled
+
+    sig { params(enabled: T::Boolean).void }
+    def initialize(enabled = true); end
+
+    sig { params(string: String).returns(T.any(Rainbow::Presenter, Rainbow::NullPresenter)) }
+    def wrap(string); end
+  end
+
+  module X11ColorNames
+    NAMES = T.let(nil, T::Hash[Symbol, [Integer, Integer, Integer]])
+  end
+end
+
+sig { params(string: String).returns(Rainbow::Presenter) }
+def Rainbow(string); end

data/sorbet/rbi/gems/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-generated=true

data/sorbet/rbi/gems/ansi.rbi

@@ -0,0 +1,398 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: true
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/ansi/all/ansi.rbi
+#
+# ansi-1.5.0
+
+module ANSI
+  def self.const_missing(name); end
+  def self.metadata; end
+  def self.string(str); end
+  extend ANSI::Code
+end
+module ANSI::Constants
+end
+module ANSI::Code
+  def [](*codes); end
+  def ansi(*codes); end
+  def back(spaces = nil); end
+  def black_on_black(string = nil); end
+  def black_on_blue(string = nil); end
+  def black_on_cyan(string = nil); end
+  def black_on_green(string = nil); end
+  def black_on_magenta(string = nil); end
+  def black_on_red(string = nil); end
+  def black_on_white(string = nil); end
+  def black_on_yellow(string = nil); end
+  def blue_on_black(string = nil); end
+  def blue_on_blue(string = nil); end
+  def blue_on_cyan(string = nil); end
+  def blue_on_green(string = nil); end
+  def blue_on_magenta(string = nil); end
+  def blue_on_red(string = nil); end
+  def blue_on_white(string = nil); end
+  def blue_on_yellow(string = nil); end
+  def code(*codes); end
+  def color(*codes); end
+  def cyan_on_black(string = nil); end
+  def cyan_on_blue(string = nil); end
+  def cyan_on_cyan(string = nil); end
+  def cyan_on_green(string = nil); end
+  def cyan_on_magenta(string = nil); end
+  def cyan_on_red(string = nil); end
+  def cyan_on_white(string = nil); end
+  def cyan_on_yellow(string = nil); end
+  def display(line, column = nil); end
+  def down(spaces = nil); end
+  def forward(spaces = nil); end
+  def green_on_black(string = nil); end
+  def green_on_blue(string = nil); end
+  def green_on_cyan(string = nil); end
+  def green_on_green(string = nil); end
+  def green_on_magenta(string = nil); end
+  def green_on_red(string = nil); end
+  def green_on_white(string = nil); end
+  def green_on_yellow(string = nil); end
+  def hex_code(string, background = nil); end
+  def left(spaces = nil); end
+  def magenta_on_black(string = nil); end
+  def magenta_on_blue(string = nil); end
+  def magenta_on_cyan(string = nil); end
+  def magenta_on_green(string = nil); end
+  def magenta_on_magenta(string = nil); end
+  def magenta_on_red(string = nil); end
+  def magenta_on_white(string = nil); end
+  def magenta_on_yellow(string = nil); end
+  def method_missing(code, *args, &blk); end
+  def move(line, column = nil); end
+  def random(background = nil); end
+  def red_on_black(string = nil); end
+  def red_on_blue(string = nil); end
+  def red_on_cyan(string = nil); end
+  def red_on_green(string = nil); end
+  def red_on_magenta(string = nil); end
+  def red_on_red(string = nil); end
+  def red_on_white(string = nil); end
+  def red_on_yellow(string = nil); end
+  def rgb(*args); end
+  def rgb_256(r, g, b); end
+  def rgb_code(red, green, blue, background = nil); end
+  def right(spaces = nil); end
+  def self.colors; end
+  def self.styles; end
+  def style(*codes); end
+  def unansi(string = nil); end
+  def uncolor(string = nil); end
+  def unstyle(string = nil); end
+  def up(spaces = nil); end
+  def white_on_black(string = nil); end
+  def white_on_blue(string = nil); end
+  def white_on_cyan(string = nil); end
+  def white_on_green(string = nil); end
+  def white_on_magenta(string = nil); end
+  def white_on_red(string = nil); end
+  def white_on_white(string = nil); end
+  def white_on_yellow(string = nil); end
+  def yellow_on_black(string = nil); end
+  def yellow_on_blue(string = nil); end
+  def yellow_on_cyan(string = nil); end
+  def yellow_on_green(string = nil); end
+  def yellow_on_magenta(string = nil); end
+  def yellow_on_red(string = nil); end
+  def yellow_on_white(string = nil); end
+  def yellow_on_yellow(string = nil); end
+  extend ANSI::Code
+  include ANSI::Constants
+end
+class ANSI::Chain
+  def codes; end
+  def initialize(string); end
+  def method_missing(s, *a, &b); end
+  def string; end
+  def to_s; end
+  def to_str; end
+end
+class String
+  def ansi!(*codes); end
+  def ansi(*codes); end
+  def unansi!; end
+  def unansi; end
+end
+module ANSI::BBCode
+  def self.ansi(colorname); end
+  def self.ansi_to_bbcode(string); end
+  def self.ansi_to_html(string); end
+  def self.bbcode_to_ansi(string, usecolors = nil); end
+  def self.bbcode_to_html(string); end
+  def self.html_to_ansi(string); end
+  def self.html_to_bbcode(string); end
+  def self.strip_bbcode(string); end
+end
+module ANSI::Terminal
+  def get_character(input = nil); end
+  def self.get_character(input = nil); end
+  def self.terminal_height; end
+  def self.terminal_size; end
+  def self.terminal_width; end
+  def terminal_height; end
+  def terminal_size; end
+  def terminal_width; end
+end
+class ANSI::Columns
+  def align; end
+  def align=(symbol); end
+  def ansi_formatting(cell, col, row); end
+  def columns; end
+  def columns=(integer); end
+  def format; end
+  def format=(procedure); end
+  def initialize(list, options = nil, &format); end
+  def inspect; end
+  def join(cols = nil); end
+  def list; end
+  def list=(list); end
+  def padding; end
+  def padding=(pad); end
+  def template(max, pad); end
+  def to_s(cols = nil); end
+  def to_s_columns(columns = nil); end
+end
+class ANSI::Diff
+  def common(x, y); end
+  def compare(x, y); end
+  def convert(object); end
+  def diff1; end
+  def diff2; end
+  def diff_string(string1, string2); end
+  def initialize(object1, object2, options = nil); end
+  def join(separator = nil); end
+  def lcs(s1, s2); end
+  def lcs_size(s1, s2); end
+  def self.diff(object1, object2, options = nil); end
+  def to_a; end
+  def to_s; end
+end
+class ANSI::Logger < Logger
+  def ansicolor=(on); end
+  def ansicolor?; end
+  def debug(progname = nil, &block); end
+  def debug_with_color; end
+  def error(progname = nil, &block); end
+  def error_with_color; end
+  def fatal(progname = nil, &block); end
+  def fatal_with_color; end
+  def formatter(&block); end
+  def info(progname = nil, &block); end
+  def info_with_color; end
+  def styles(options = nil); end
+  def warn(progname = nil, &block); end
+  def warn_with_color; end
+end
+class Logger
+end
+class Logger::LogDevice
+  def ansicolor=(arg0); end
+  def ansicolor?; end
+end
+module ANSI::Mixin
+  def black; end
+  def black_on_blue; end
+  def black_on_cyan; end
+  def black_on_green; end
+  def black_on_magenta; end
+  def black_on_red; end
+  def black_on_white; end
+  def black_on_yellow; end
+  def blink; end
+  def blue; end
+  def blue_on_black; end
+  def blue_on_cyan; end
+  def blue_on_green; end
+  def blue_on_magenta; end
+  def blue_on_red; end
+  def blue_on_white; end
+  def blue_on_yellow; end
+  def bold; end
+  def concealed; end
+  def cyan; end
+  def cyan_on_black; end
+  def cyan_on_blue; end
+  def cyan_on_green; end
+  def cyan_on_magenta; end
+  def cyan_on_red; end
+  def cyan_on_white; end
+  def cyan_on_yellow; end
+  def dark; end
+  def display(line, column = nil); end
+  def green; end
+  def green_on_black; end
+  def green_on_blue; end
+  def green_on_cyan; end
+  def green_on_magenta; end
+  def green_on_red; end
+  def green_on_white; end
+  def green_on_yellow; end
+  def italic; end
+  def magenta; end
+  def magenta_on_black; end
+  def magenta_on_blue; end
+  def magenta_on_cyan; end
+  def magenta_on_green; end
+  def magenta_on_red; end
+  def magenta_on_white; end
+  def magenta_on_yellow; end
+  def negative; end
+  def on_black; end
+  def on_blue; end
+  def on_cyan; end
+  def on_green; end
+  def on_magenta; end
+  def on_red; end
+  def on_white; end
+  def on_yellow; end
+  def rapid; end
+  def red; end
+  def red_on_black; end
+  def red_on_blue; end
+  def red_on_cyan; end
+  def red_on_green; end
+  def red_on_magenta; end
+  def red_on_white; end
+  def red_on_yellow; end
+  def reverse; end
+  def strike; end
+  def underline; end
+  def underscore; end
+  def white; end
+  def white_on_black; end
+  def white_on_blue; end
+  def white_on_cyan; end
+  def white_on_green; end
+  def white_on_magenta; end
+  def white_on_red; end
+  def white_on_yellow; end
+  def yellow; end
+  def yellow_on_black; end
+  def yellow_on_blue; end
+  def yellow_on_cyan; end
+  def yellow_on_green; end
+  def yellow_on_magenta; end
+  def yellow_on_red; end
+  def yellow_on_white; end
+end
+class ANSI::ProgressBar
+  def bar; end
+  def bar_mark=(mark); end
+  def barmark=(mark); end
+  def bytes; end
+  def clear; end
+  def colorize(part, style); end
+  def convert_bytes(bytes); end
+  def elapsed; end
+  def eol; end
+  def eta; end
+  def file_transfer_mode; end
+  def finish; end
+  def flush; end
+  def format(format, *arguments); end
+  def format=(arg0); end
+  def format_arguments; end
+  def format_arguments=(arg0); end
+  def format_time(t); end
+  def get_width; end
+  def halt; end
+  def inc(step = nil); end
+  def initialize(title, total, out = nil); end
+  def inspect; end
+  def mark=(mark); end
+  def percentage; end
+  def reset; end
+  def set(count); end
+  def show; end
+  def show_progress; end
+  def standard_mode; end
+  def stat; end
+  def stat_for_file_transfer; end
+  def style(options); end
+  def styles; end
+  def styles=(arg0); end
+  def title; end
+  def title=(str); end
+  def total_overflow=(boolv); end
+  def transfer_mode; end
+  def transfer_rate; end
+end
+class ANSI::String
+  def +(other); end
+  def [](*args); end
+  def ansi!(code); end
+  def ansi(code); end
+  def black!; end
+  def black; end
+  def blue!; end
+  def blue; end
+  def bold!; end
+  def bold; end
+  def color!(code); end
+  def color(code); end
+  def cyan!; end
+  def cyan; end
+  def downcase!; end
+  def downcase; end
+  def green!; end
+  def green; end
+  def gsub!(pattern, replacement = nil, &block); end
+  def gsub(pattern, replacement = nil, &block); end
+  def initialize(text = nil, marks = nil); end
+  def magenta!; end
+  def magenta; end
+  def marks; end
+  def red!; end
+  def red; end
+  def shift_marks!(index, delta); end
+  def shift_marks(index, delta, marks = nil); end
+  def size; end
+  def slice(*args); end
+  def sub!(pattern, replacement = nil, &block); end
+  def sub(pattern, replacement = nil, &block); end
+  def text; end
+  def to_s; end
+  def to_str; end
+  def underline!; end
+  def underline; end
+  def upcase!; end
+  def upcase; end
+  def yellow!; end
+  def yellow; end
+end
+class ANSI::Table
+  def align; end
+  def align=(arg0); end
+  def ansi_formating(cell, col, row); end
+  def apply_format(str, cell, col, row); end
+  def border; end
+  def border=(arg0); end
+  def cell_template(max); end
+  def column_size; end
+  def dividing_line; end
+  def fit; end
+  def fit=(arg0); end
+  def fit_width; end
+  def format; end
+  def format=(arg0); end
+  def initialize(table, options = nil, &format); end
+  def max_columns(fit = nil); end
+  def padding; end
+  def padding=(arg0); end
+  def table; end
+  def table=(arg0); end
+  def to_s; end
+end
+class Object < BasicObject
+  def ansi(string, *codes); end
+end