rbs-relaxed 3.9.0.1

data/stdlib/zlib/0/gzip_reader.rbs

@@ -0,0 +1,293 @@
+%a{annotate:rdoc:skip}
+module Zlib
+  # <!-- rdoc-file=ext/zlib/zlib.c -->
+  # Zlib::GzipReader is the class for reading a gzipped file.  GzipReader should
+  # be used as an IO, or -IO-like, object.
+  #
+  #     Zlib::GzipReader.open('hoge.gz') {|gz|
+  #       print gz.read
+  #     }
+  #
+  #     File.open('hoge.gz') do |f|
+  #       gz = Zlib::GzipReader.new(f)
+  #       print gz.read
+  #       gz.close
+  #     end
+  #
+  # ## Method Catalogue
+  #
+  # The following methods in Zlib::GzipReader are just like their counterparts in
+  # IO, but they raise Zlib::Error or Zlib::GzipFile::Error exception if an error
+  # was found in the gzip file.
+  # *   #each
+  # *   #each_line
+  # *   #each_byte
+  # *   #gets
+  # *   #getc
+  # *   #lineno
+  # *   #lineno=
+  # *   #read
+  # *   #readchar
+  # *   #readline
+  # *   #readlines
+  # *   #ungetc
+  #
+  # Be careful of the footer of the gzip file. A gzip file has the checksum of
+  # pre-compressed data in its footer. GzipReader checks all uncompressed data
+  # against that checksum at the following cases, and if it fails, raises
+  # `Zlib::GzipFile::NoFooter`, `Zlib::GzipFile::CRCError`, or
+  # `Zlib::GzipFile::LengthError` exception.
+  #
+  # *   When an reading request is received beyond the end of file (the end of
+  #     compressed data). That is, when Zlib::GzipReader#read,
+  #     Zlib::GzipReader#gets, or some other methods for reading returns nil.
+  # *   When Zlib::GzipFile#close method is called after the object reaches the
+  #     end of file.
+  # *   When Zlib::GzipReader#unused method is called after the object reaches the
+  #     end of file.
+  #
+  # The rest of the methods are adequately described in their own documentation.
+  #
+  class GzipReader < Zlib::GzipFile
+    include Enumerable[String]
+
+    def self.wrap: (IO io) -> instance
+                 | (IO io) { (instance gz) -> void } -> void
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - Zlib::GzipReader.open(filename) {|gz| ... }
+    # -->
+    # Opens a file specified by `filename` as a gzipped file, and returns a
+    # GzipReader object associated with that file.  Further details of this method
+    # are in Zlib::GzipReader.new and ZLib::GzipFile.wrap.
+    #
+    def self.open: (String | _ToPath filename) -> instance
+                 | (String | _ToPath filename) { (instance gz) -> void } -> void
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - Zlib::GzipReader.zcat(io, options = {}, &block) => nil
+    #   - Zlib::GzipReader.zcat(io, options = {}) => string
+    # -->
+    # Decompresses all gzip data in the `io`, handling multiple gzip streams until
+    # the end of the `io`.  There should not be any non-gzip data after the gzip
+    # streams.
+    #
+    # If a block is given, it is yielded strings of uncompressed data, and the
+    # method returns `nil`. If a block is not given, the method returns the
+    # concatenation of all uncompressed data in all gzip streams.
+    #
+    def self.zcat: (IO io, **untyped) -> String
+                 | (IO io, **untyped) { (String chunk) -> void } -> nil
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - each(*args)
+    # -->
+    # See Zlib::GzipReader documentation for a description.
+    #
+    def each: (*untyped) { (String) -> void } -> void
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - each_byte()
+    # -->
+    # See Zlib::GzipReader documentation for a description.
+    #
+    def each_byte: () { (String) -> void } -> void
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - each_char()
+    # -->
+    # See Zlib::GzipReader documentation for a description.
+    #
+    def each_char: () { (String) -> void } -> void
+
+    # <!-- rdoc-file=ext/zlib/zlib.c -->
+    # See Zlib::GzipReader documentation for a description.
+    #
+    def each_line: (*untyped) { (String) -> void } -> void
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - eof()
+    # -->
+    # Returns `true` or `false` whether the stream has reached the end.
+    #
+    def eof: () -> bool
+
+    # <!-- rdoc-file=ext/zlib/zlib.c -->
+    # Returns `true` or `false` whether the stream has reached the end.
+    #
+    def eof?: () -> bool
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - external_encoding()
+    # -->
+    # See Zlib::GzipReader documentation for a description.
+    #
+    def external_encoding: () -> Encoding
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - getbyte()
+    # -->
+    # See Zlib::GzipReader documentation for a description.
+    #
+    def getbyte: () -> Integer?
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - getc()
+    # -->
+    # See Zlib::GzipReader documentation for a description.
+    #
+    def getc: () -> String?
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - gets(*args)
+    # -->
+    # See Zlib::GzipReader documentation for a description. However, note that this
+    # method can return `nil` even if #eof? returns false, unlike the behavior of
+    # File#gets.
+    #
+    def gets: (?String sep, ?Integer limit) -> String?
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - lineno()
+    # -->
+    # The line number of the last row read from this file.
+    #
+    def lineno: () -> Integer
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - lineno=(p1)
+    # -->
+    # Specify line number of the last row read from this file.
+    #
+    def lineno=: (Integer arg0) -> Integer
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - pos()
+    # -->
+    # Total number of output bytes output so far.
+    #
+    def pos: () -> Integer
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - read(p1 = v1, p2 = v2)
+    # -->
+    # See Zlib::GzipReader documentation for a description.
+    #
+    def read: (?int? length, ?string outbuf) -> String?
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - readbyte()
+    # -->
+    # See Zlib::GzipReader documentation for a description.
+    #
+    def readbyte: () -> Integer
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - readchar()
+    # -->
+    # See Zlib::GzipReader documentation for a description.
+    #
+    def readchar: () -> String
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - readline(*args)
+    # -->
+    # See Zlib::GzipReader documentation for a description.
+    #
+    def readline: (?String sep, ?Integer limit) -> String
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - readlines(*args)
+    # -->
+    # See Zlib::GzipReader documentation for a description.
+    #
+    def readlines: (?String sep, ?Integer limit) -> ::Array[String]
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - gzipreader.readpartial(maxlen [, outbuf]) => string, outbuf
+    # -->
+    # Reads at most *maxlen* bytes from the gzipped stream but it blocks only if
+    # *gzipreader* has no data immediately available. If the optional *outbuf*
+    # argument is present, it must reference a String, which will receive the data.
+    # It raises `EOFError` on end of file.
+    #
+    def readpartial: (int maxlen, ?string outbuf) -> String
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - rewind()
+    # -->
+    # Resets the position of the file pointer to the point created the GzipReader
+    # object.  The associated IO object needs to respond to the `seek` method.
+    #
+    def rewind: () -> Integer
+
+    # <!-- rdoc-file=ext/zlib/zlib.c -->
+    # Total number of output bytes output so far.
+    #
+    def tell: () -> Integer
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - ungetbyte(p1)
+    # -->
+    # See Zlib::GzipReader documentation for a description.
+    #
+    def ungetbyte: (String | Integer arg0) -> NilClass
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - ungetc(p1)
+    # -->
+    # See Zlib::GzipReader documentation for a description.
+    #
+    def ungetc: (String arg0) -> NilClass
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - unused()
+    # -->
+    # Returns the rest of the data which had read for parsing gzip format, or `nil`
+    # if the whole gzip file is not parsed yet.
+    #
+    def unused: () -> String?
+
+    private
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - Zlib::GzipReader.new(io, options = {})
+    # -->
+    # Creates a GzipReader object associated with `io`. The GzipReader object reads
+    # gzipped data from `io`, and parses/decompresses it.  The `io` must have a
+    # `read` method that behaves same as the IO#read.
+    #
+    # The `options` hash may be used to set the encoding of the data.
+    # `:external_encoding`, `:internal_encoding` and `:encoding` may be set as in
+    # IO::new.
+    #
+    # If the gzip file header is incorrect, raises an Zlib::GzipFile::Error
+    # exception.
+    #
+    def initialize: (_Reader io, **untyped opts) -> void
+  end
+end

data/stdlib/zlib/0/gzip_writer.rbs

@@ -0,0 +1,166 @@
+%a{annotate:rdoc:skip}
+module Zlib
+  # <!-- rdoc-file=ext/zlib/zlib.c -->
+  # Zlib::GzipWriter is a class for writing gzipped files.  GzipWriter should be
+  # used with an instance of IO, or IO-like, object.
+  #
+  # Following two example generate the same result.
+  #
+  #     Zlib::GzipWriter.open('hoge.gz') do |gz|
+  #       gz.write 'jugemu jugemu gokou no surikire...'
+  #     end
+  #
+  #     File.open('hoge.gz', 'w') do |f|
+  #       gz = Zlib::GzipWriter.new(f)
+  #       gz.write 'jugemu jugemu gokou no surikire...'
+  #       gz.close
+  #     end
+  #
+  # To make like gzip(1) does, run following:
+  #
+  #     orig = 'hoge.txt'
+  #     Zlib::GzipWriter.open('hoge.gz') do |gz|
+  #       gz.mtime = File.mtime(orig)
+  #       gz.orig_name = orig
+  #       gz.write IO.binread(orig)
+  #     end
+  #
+  # NOTE: Due to the limitation of Ruby's finalizer, you must explicitly close
+  # GzipWriter objects by Zlib::GzipWriter#close etc.  Otherwise, GzipWriter will
+  # be not able to write the gzip footer and will generate a broken gzip file.
+  #
+  class GzipWriter < Zlib::GzipFile
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - Zlib::GzipWriter.open(filename, level=nil, strategy=nil) { |gz| ... }
+    # -->
+    # Opens a file specified by `filename` for writing gzip compressed data, and
+    # returns a GzipWriter object associated with that file.  Further details of
+    # this method are found in Zlib::GzipWriter.new and Zlib::GzipFile.wrap.
+    #
+    def self.open: (String filename) { (instance gz) -> void } -> instance
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - <<(p1)
+    # -->
+    # Same as IO.
+    #
+    def <<: (_ToS obj) -> self
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - comment=(p1)
+    # -->
+    # Specify the comment (`str`) in the gzip header.
+    #
+    def comment=: (String arg0) -> void
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - flush(flush=nil)
+    # -->
+    # Flushes all the internal buffers of the GzipWriter object.  The meaning of
+    # `flush` is same as in Zlib::Deflate#deflate.  `Zlib::SYNC_FLUSH` is used if
+    # `flush` is omitted.  It is no use giving flush `Zlib::NO_FLUSH`.
+    #
+    def flush: (?Integer flush) -> String
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - mtime=(p1)
+    # -->
+    # Specify the modification time (`mtime`) in the gzip header. Using an Integer.
+    #
+    # Setting the mtime in the gzip header does not effect the mtime of the file
+    # generated. Different utilities that expand the gzipped files may use the mtime
+    # header. For example the gunzip utility can use the `-N` flag which will set
+    # the resultant file's mtime to the value in the header. By default many tools
+    # will set the mtime of the expanded file to the mtime of the gzipped file, not
+    # the mtime in the header.
+    #
+    # If you do not set an mtime, the default value will be the time when
+    # compression started. Setting a value of 0 indicates no time stamp is
+    # available.
+    #
+    def mtime=: (string | _ToPath | IO file_name) -> Time
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - orig_name=(p1)
+    # -->
+    # Specify the original name (`str`) in the gzip header.
+    #
+    def orig_name=: (String arg0) -> void
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - pos()
+    # -->
+    # Total number of input bytes read so far.
+    #
+    def pos: () -> Integer
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - print(*args)
+    # -->
+    # Same as IO.
+    #
+    def print: (*untyped arg0) -> NilClass
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - printf(*args)
+    # -->
+    # Same as IO.
+    #
+    def printf: (String format_string, *untyped arg0) -> NilClass
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - putc(p1)
+    # -->
+    # Same as IO.
+    #
+    def putc: (Numeric | String arg0) -> untyped
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - puts(*args)
+    # -->
+    # Same as IO.
+    #
+    def puts: (*untyped arg0) -> NilClass
+
+    # <!-- rdoc-file=ext/zlib/zlib.c -->
+    # Total number of input bytes read so far.
+    #
+    def tell: () -> Integer
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - write(*args)
+    # -->
+    # Same as IO.
+    #
+    def write: (*_ToS string) -> Integer
+
+    private
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - Zlib::GzipWriter.new(io, level = nil, strategy = nil, options = {})
+    # -->
+    # Creates a GzipWriter object associated with `io`. `level` and `strategy`
+    # should be the same as the arguments of Zlib::Deflate.new.  The GzipWriter
+    # object writes gzipped data to `io`.  `io` must respond to the `write` method
+    # that behaves the same as IO#write.
+    #
+    # The `options` hash may be used to set the encoding of the data.
+    # `:external_encoding`, `:internal_encoding` and `:encoding` may be set as in
+    # IO::new.
+    #
+    def initialize: (_Writer io, Integer level, Integer strategy, **untyped opts) -> void
+  end
+end

data/stdlib/zlib/0/inflate.rbs

@@ -0,0 +1,180 @@
+%a{annotate:rdoc:skip}
+module Zlib
+  # <!-- rdoc-file=ext/zlib/zlib.c -->
+  # Zlib:Inflate is the class for decompressing compressed data.  Unlike
+  # Zlib::Deflate, an instance of this class is not able to duplicate (clone, dup)
+  # itself.
+  #
+  class Inflate < Zlib::ZStream
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - Zlib.inflate(string)
+    #   - Zlib::Inflate.inflate(string)
+    # -->
+    # Decompresses `string`. Raises a Zlib::NeedDict exception if a preset
+    # dictionary is needed for decompression.
+    #
+    # This method is almost equivalent to the following code:
+    #
+    #     def inflate(string)
+    #       zstream = Zlib::Inflate.new
+    #       buf = zstream.inflate(string)
+    #       zstream.finish
+    #       zstream.close
+    #       buf
+    #     end
+    #
+    # See also Zlib.deflate
+    #
+    def self.inflate: (string string) -> String
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - <<(p1)
+    # -->
+    # Same as IO.
+    #
+    def <<: (_ToS obj) -> self
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - add_dictionary(string)
+    # -->
+    # Provide the inflate stream with a dictionary that may be required in the
+    # future.  Multiple dictionaries may be provided.  The inflate stream will
+    # automatically choose the correct user-provided dictionary based on the
+    # stream's required dictionary.
+    #
+    def add_dictionary: (String arg0) -> void
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - inflate(deflate_string, buffer: nil)                 -> String
+    #   - inflate(deflate_string, buffer: nil) { |chunk| ... } -> nil
+    # -->
+    # Inputs `deflate_string` into the inflate stream and returns the output from
+    # the stream.  Calling this method, both the input and the output buffer of the
+    # stream are flushed.  If string is `nil`, this method finishes the stream, just
+    # like Zlib::ZStream#finish.
+    #
+    # If a block is given consecutive inflated chunks from the `deflate_string` are
+    # yielded to the block and `nil` is returned.
+    #
+    # If a :buffer keyword argument is given and not nil:
+    #
+    # *   The :buffer keyword should be a String, and will used as the output
+    #     buffer. Using this option can reuse the memory required during inflation.
+    # *   When not passing a block, the return value will be the same object as the
+    #     :buffer keyword argument.
+    # *   When passing a block, the yielded chunks will be the same value as the
+    #     :buffer keyword argument.
+    #
+    # Raises a Zlib::NeedDict exception if a preset dictionary is needed to
+    # decompress.  Set the dictionary by Zlib::Inflate#set_dictionary and then call
+    # this method again with an empty string to flush the stream:
+    #
+    #     inflater = Zlib::Inflate.new
+    #
+    #     begin
+    #       out = inflater.inflate compressed
+    #     rescue Zlib::NeedDict
+    #       # ensure the dictionary matches the stream's required dictionary
+    #       raise unless inflater.adler == Zlib.adler32(dictionary)
+    #
+    #       inflater.set_dictionary dictionary
+    #       inflater.inflate ''
+    #     end
+    #
+    #     # ...
+    #
+    #     inflater.close
+    #
+    # See also Zlib::Inflate.new
+    #
+    def inflate: (string string, ?buffer: String) -> String
+               | (string string, ?buffer: String) { (String chunk) -> nil } -> nil
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - set_dictionary(p1)
+    # -->
+    # Sets the preset dictionary and returns `string`.  This method is available
+    # just only after a Zlib::NeedDict exception was raised.  See zlib.h for
+    # details.
+    #
+    def set_dictionary: (String p1) -> String
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - sync(string)
+    # -->
+    # Inputs `string` into the end of input buffer and skips data until a full flush
+    # point can be found.  If the point is found in the buffer, this method flushes
+    # the buffer and returns false.  Otherwise it returns `true` and the following
+    # data of full flush point is preserved in the buffer.
+    #
+    def sync: (String string) -> bool
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - sync_point?()
+    # -->
+    # Quoted verbatim from original documentation:
+    #
+    #     What is this?
+    #
+    # `:)`
+    #
+    def sync_point?: () -> bool
+
+    private
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - Zlib::Inflate.new(window_bits = Zlib::MAX_WBITS)
+    # -->
+    # Creates a new inflate stream for decompression.  `window_bits` sets the size
+    # of the history buffer and can have the following values:
+    #
+    # 0
+    # :   Have inflate use the window size from the zlib header of the compressed
+    #     stream.
+    #
+    #
+    # (8..15)
+    # :   Overrides the window size of the inflate header in the compressed stream.
+    #     The window size must be greater than or equal to the window size of the
+    #     compressed stream.
+    #
+    #
+    # Greater than 15
+    # :   Add 32 to window_bits to enable zlib and gzip decoding with automatic
+    #     header detection, or add 16 to decode only the gzip format (a
+    #     Zlib::DataError will be raised for a non-gzip stream).
+    #
+    #
+    # (-8..-15)
+    # :   Enables raw deflate mode which will not generate a check value, and will
+    #     not look for any check values for comparison at the end of the stream.
+    #
+    #     This is for use with other formats that use the deflate compressed data
+    #     format such as zip which provide their own check values.
+    #
+    #
+    # ## Example
+    #
+    #     open "compressed.file" do |compressed_io|
+    #       zi = Zlib::Inflate.new(Zlib::MAX_WBITS + 32)
+    #
+    #       begin
+    #         open "uncompressed.file", "w+" do |uncompressed_io|
+    #           uncompressed_io << zi.inflate(compressed_io.read)
+    #         end
+    #       ensure
+    #         zi.close
+    #       end
+    #     end
+    #
+    def initialize: (?Integer window_bits) -> void
+  end
+end

data/stdlib/zlib/0/mem_error.rbs

@@ -0,0 +1,10 @@
+%a{annotate:rdoc:skip}
+module Zlib
+  # <!-- rdoc-file=ext/zlib/zlib.c -->
+  # Subclass of Zlib::Error
+  #
+  # When zlib returns a Z_MEM_ERROR, usually if there was not enough memory.
+  #
+  class MemError < Zlib::Error
+  end
+end

data/stdlib/zlib/0/need_dict.rbs

@@ -0,0 +1,13 @@
+%a{annotate:rdoc:skip}
+module Zlib
+  # <!-- rdoc-file=ext/zlib/zlib.c -->
+  # Subclass of Zlib::Error
+  #
+  # When zlib returns a Z_NEED_DICT if a preset dictionary is needed at this
+  # point.
+  #
+  # Used by Zlib::Inflate.inflate and `Zlib.inflate`
+  #
+  class NeedDict < Zlib::Error
+  end
+end

data/stdlib/zlib/0/stream_end.rbs

@@ -0,0 +1,11 @@
+%a{annotate:rdoc:skip}
+module Zlib
+  # <!-- rdoc-file=ext/zlib/zlib.c -->
+  # Subclass of Zlib::Error
+  #
+  # When zlib returns a Z_STREAM_END is return if the end of the compressed data
+  # has been reached and all uncompressed out put has been produced.
+  #
+  class StreamEnd < Zlib::Error
+  end
+end

data/stdlib/zlib/0/stream_error.rbs

@@ -0,0 +1,11 @@
+%a{annotate:rdoc:skip}
+module Zlib
+  # <!-- rdoc-file=ext/zlib/zlib.c -->
+  # Subclass of Zlib::Error
+  #
+  # When zlib returns a Z_STREAM_ERROR, usually if the stream state was
+  # inconsistent.
+  #
+  class StreamError < Zlib::Error
+  end
+end

data/stdlib/zlib/0/version_error.rbs

@@ -0,0 +1,11 @@
+%a{annotate:rdoc:skip}
+module Zlib
+  # <!-- rdoc-file=ext/zlib/zlib.c -->
+  # Subclass of Zlib::Error
+  #
+  # When zlib returns a Z_VERSION_ERROR, usually if the zlib library version is
+  # incompatible with the version assumed by the caller.
+  #
+  class VersionError < Zlib::Error
+  end
+end