roast-ai 0.4.8 → 0.4.10

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/annotations/webmock.rbi

@@ -0,0 +1,9 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+class Minitest::Test
+  include WebMock::API
+end

data/sorbet/rbi/gems/marcel@1.1.0.rbi

@@ -0,0 +1,239 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `marcel` gem.
+# Please instead update this file by running `bin/tapioca gem marcel`.
+
+
+# This file is auto-generated. Instead of editing this file, please
+# add MIMEs to data/custom.xml or lib/marcel/mime_type/definitions.rb.
+#
+# source://marcel//lib/marcel.rb#3
+module Marcel; end
+
+# @private
+#
+# source://marcel//lib/marcel/tables.rb#9
+Marcel::EXTENSIONS = T.let(T.unsafe(nil), Hash)
+
+# @private
+#
+# source://marcel//lib/marcel/tables.rb#2513
+Marcel::MAGIC = T.let(T.unsafe(nil), Array)
+
+# Mime type detection
+#
+# source://marcel//lib/marcel/magic.rb#12
+class Marcel::Magic
+  # Mime type by type string
+  #
+  # @return [Magic] a new instance of Magic
+  #
+  # source://marcel//lib/marcel/magic.rb#16
+  def initialize(type); end
+
+  # Allow comparison with string
+  #
+  # @return [Boolean]
+  #
+  # source://marcel//lib/marcel/magic.rb#103
+  def ==(other); end
+
+  # @return [Boolean]
+  #
+  # source://marcel//lib/marcel/magic.rb#54
+  def audio?; end
+
+  # Returns true if type is child of parent type
+  #
+  # @return [Boolean]
+  #
+  # source://marcel//lib/marcel/magic.rb#58
+  def child_of?(parent); end
+
+  # Get mime comment
+  #
+  # source://marcel//lib/marcel/magic.rb#68
+  def comment; end
+
+  # Allow comparison with string
+  #
+  # @return [Boolean]
+  #
+  # source://marcel//lib/marcel/magic.rb#103
+  def eql?(other); end
+
+  # Get string list of file extensions
+  #
+  # source://marcel//lib/marcel/magic.rb#63
+  def extensions; end
+
+  # source://marcel//lib/marcel/magic.rb#107
+  def hash; end
+
+  # Mediatype shortcuts
+  #
+  # @return [Boolean]
+  #
+  # source://marcel//lib/marcel/magic.rb#53
+  def image?; end
+
+  # Returns the value of attribute mediatype.
+  #
+  # source://marcel//lib/marcel/magic.rb#13
+  def mediatype; end
+
+  # Returns the value of attribute subtype.
+  #
+  # source://marcel//lib/marcel/magic.rb#13
+  def subtype; end
+
+  # Returns true if type is a text format
+  #
+  # @return [Boolean]
+  #
+  # source://marcel//lib/marcel/magic.rb#50
+  def text?; end
+
+  # Return type as string
+  #
+  # source://marcel//lib/marcel/magic.rb#98
+  def to_s; end
+
+  # Returns the value of attribute type.
+  #
+  # source://marcel//lib/marcel/magic.rb#13
+  def type; end
+
+  # @return [Boolean]
+  #
+  # source://marcel//lib/marcel/magic.rb#55
+  def video?; end
+
+  class << self
+    # Add custom mime type. Arguments:
+    # * <i>type</i>: Mime type
+    # * <i>options</i>: Options hash
+    #
+    # Option keys:
+    # * <i>:extensions</i>: String list or single string of file extensions
+    # * <i>:parents</i>: String list or single string of parent mime types
+    # * <i>:magic</i>: Mime magic specification
+    # * <i>:comment</i>: Comment string
+    #
+    # source://marcel//lib/marcel/magic.rb#30
+    def add(type, options); end
+
+    # Lookup all mime types by magic content analysis.
+    # This is a slower operation.
+    #
+    # source://marcel//lib/marcel/magic.rb#93
+    def all_by_magic(io); end
+
+    # Lookup mime type by file extension
+    #
+    # source://marcel//lib/marcel/magic.rb#73
+    def by_extension(ext); end
+
+    # Lookup mime type by magic content analysis.
+    # This is a slow operation.
+    #
+    # source://marcel//lib/marcel/magic.rb#86
+    def by_magic(io); end
+
+    # Lookup mime type by filename
+    #
+    # source://marcel//lib/marcel/magic.rb#80
+    def by_path(path); end
+
+    # @return [Boolean]
+    #
+    # source://marcel//lib/marcel/magic.rb#113
+    def child?(child, parent); end
+
+    # Removes a mime type from the dictionary.  You might want to do this if
+    # you're seeing impossible conflicts (for instance, application/x-gmc-link).
+    # * <i>type</i>: The mime type to remove.  All associated extensions and magic are removed too.
+    #
+    # source://marcel//lib/marcel/magic.rb#42
+    def remove(type); end
+
+    private
+
+    # source://marcel//lib/marcel/magic.rb#117
+    def magic_match(io, method); end
+
+    # source://marcel//lib/marcel/magic.rb#127
+    def magic_match_io(io, matches, buffer); end
+  end
+end
+
+# source://marcel//lib/marcel/mime_type.rb#4
+class Marcel::MimeType
+  class << self
+    # source://marcel//lib/marcel/mime_type.rb#8
+    def extend(type, extensions: T.unsafe(nil), parents: T.unsafe(nil), magic: T.unsafe(nil)); end
+
+    # Returns the most appropriate content type for the given file.
+    #
+    # The first argument should be a +Pathname+ or an +IO+. If it is a +Pathname+, the specified
+    # file will be opened first.
+    #
+    # Optional parameters:
+    # * +name+: file name, if known
+    # * +extension+: file extension, if known
+    # * +declared_type+: MIME type, if known
+    #
+    # The most appropriate type is determined by the following:
+    # * type declared by binary magic number data
+    # * type declared by the first of file name, file extension, or declared MIME type
+    #
+    # If no type can be determined, then +application/octet-stream+ is returned.
+    #
+    # source://marcel//lib/marcel/mime_type.rb#29
+    def for(pathname_or_io = T.unsafe(nil), name: T.unsafe(nil), extension: T.unsafe(nil), declared_type: T.unsafe(nil)); end
+
+    private
+
+    # source://marcel//lib/marcel/mime_type.rb#36
+    def for_data(pathname_or_io); end
+
+    # source://marcel//lib/marcel/mime_type.rb#62
+    def for_declared_type(declared_type); end
+
+    # source://marcel//lib/marcel/mime_type.rb#54
+    def for_extension(extension); end
+
+    # source://marcel//lib/marcel/mime_type.rb#46
+    def for_name(name); end
+
+    # For some document types (notably Microsoft Office) we recognise the main content
+    # type with magic, but not the specific subclass. In this situation, if we can get a more
+    # specific class using either the name or declared_type, we should use that in preference
+    #
+    # source://marcel//lib/marcel/mime_type.rb#89
+    def most_specific_type(*candidates); end
+
+    # source://marcel//lib/marcel/mime_type.rb#79
+    def parse_media_type(content_type); end
+
+    # source://marcel//lib/marcel/mime_type.rb#71
+    def with_io(pathname_or_io, &block); end
+  end
+end
+
+# source://marcel//lib/marcel/mime_type.rb#5
+Marcel::MimeType::BINARY = T.let(T.unsafe(nil), String)
+
+# @private
+#
+# source://marcel//lib/marcel/tables.rb#1310
+Marcel::TYPE_EXTS = T.let(T.unsafe(nil), Hash)
+
+# Cooltalk Audio
+#
+# source://marcel//lib/marcel/tables.rb#2239
+Marcel::TYPE_PARENTS = T.let(T.unsafe(nil), Hash)
+
+# source://marcel//lib/marcel/version.rb#4
+Marcel::VERSION = T.let(T.unsafe(nil), String)