rbs 2.8.4 → 3.8.1

data/stdlib/zlib/0/deflate.rbs

@@ -0,0 +1,210 @@
+%a{annotate:rdoc:skip}
+module Zlib
+  # <!-- rdoc-file=ext/zlib/zlib.c -->
+  # Zlib::Deflate is the class for compressing data.  See Zlib::ZStream for more
+  # information.
+  #
+  class Deflate < Zlib::ZStream
+    type compression_level = Integer
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - Zlib.deflate(string[, level])
+    #   - Zlib::Deflate.deflate(string[, level])
+    # -->
+    # Compresses the given `string`. Valid values of level are Zlib::NO_COMPRESSION,
+    # Zlib::BEST_SPEED, Zlib::BEST_COMPRESSION, Zlib::DEFAULT_COMPRESSION, or an
+    # integer from 0 to 9.
+    #
+    # This method is almost equivalent to the following code:
+    #
+    #     def deflate(string, level)
+    #       z = Zlib::Deflate.new(level)
+    #       dst = z.deflate(string, Zlib::FINISH)
+    #       z.close
+    #       dst
+    #     end
+    #
+    # See also Zlib.inflate
+    #
+    def self.deflate: (string string, ?compression_level level) -> String
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - << string
+    # -->
+    # Inputs `string` into the deflate stream just like Zlib::Deflate#deflate, but
+    # returns the Zlib::Deflate object itself.  The output from the stream is
+    # preserved in output buffer.
+    #
+    def <<: (string string) -> self
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - z.deflate(string, flush = Zlib::NO_FLUSH)                 -> String
+    #   - z.deflate(string, flush = Zlib::NO_FLUSH) { |chunk| ... } -> nil
+    # -->
+    # Inputs `string` into the deflate stream and returns the output from the
+    # stream.  On calling this method, both the input and the output buffers 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 deflated chunks from the `string` are yielded
+    # to the block and `nil` is returned.
+    #
+    # The `flush` parameter specifies the flush mode.  The following constants may
+    # be used:
+    #
+    # Zlib::NO_FLUSH
+    # :   The default
+    #
+    # Zlib::SYNC_FLUSH
+    # :   Flushes the output to a byte boundary
+    #
+    # Zlib::FULL_FLUSH
+    # :   SYNC_FLUSH + resets the compression state
+    #
+    # Zlib::FINISH
+    # :   Pending input is processed, pending output is flushed.
+    #
+    #
+    # See the constants for further description.
+    #
+    def deflate: (string string, ?Integer flush) -> String
+               | (string string, ?Integer flush) { (String chunk) -> nil } -> nil
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - flush(flush = Zlib::SYNC_FLUSH)                 -> String
+    #   - flush(flush = Zlib::SYNC_FLUSH) { |chunk| ... } -> nil
+    # -->
+    # This method is equivalent to `deflate('', flush)`. This method is just
+    # provided to improve the readability of your Ruby program.  If a block is given
+    # chunks of deflate output are yielded to the block until the buffer is flushed.
+    #
+    # See Zlib::Deflate#deflate for detail on the `flush` constants NO_FLUSH,
+    # SYNC_FLUSH, FULL_FLUSH and FINISH.
+    #
+    def flush: (?Integer flush) -> String
+             | (?Integer flush) { (String chunk) -> nil } -> nil
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - params(level, strategy)
+    # -->
+    # Changes the parameters of the deflate stream to allow changes between
+    # different types of data that require different types of compression.  Any
+    # unprocessed data is flushed before changing the params.
+    #
+    # See Zlib::Deflate.new for a description of `level` and `strategy`.
+    #
+    def params: (compression_level level, Integer strategy) -> void
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - set_dictionary(string)
+    # -->
+    # Sets the preset dictionary and returns `string`. This method is available just
+    # only after Zlib::Deflate.new or Zlib::ZStream#reset method was called. See
+    # zlib.h for details.
+    #
+    # Can raise errors of Z_STREAM_ERROR if a parameter is invalid (such as NULL
+    # dictionary) or the stream state is inconsistent, Z_DATA_ERROR if the given
+    # dictionary doesn't match the expected one (incorrect adler32 value)
+    #
+    def set_dictionary: (String dictionary) -> String
+
+    private
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - Zlib::Deflate.new(level=DEFAULT_COMPRESSION, window_bits=MAX_WBITS, mem_level=DEF_MEM_LEVEL, strategy=DEFAULT_STRATEGY)
+    # -->
+    # Creates a new deflate stream for compression. If a given argument is nil, the
+    # default value of that argument is used.
+    #
+    # The `level` sets the compression level for the deflate stream between 0 (no
+    # compression) and 9 (best compression). The following constants have been
+    # defined to make code more readable:
+    #
+    # *   Zlib::DEFAULT_COMPRESSION
+    # *   Zlib::NO_COMPRESSION
+    # *   Zlib::BEST_SPEED
+    # *   Zlib::BEST_COMPRESSION
+    #
+    # See http://www.zlib.net/manual.html#Constants for further information.
+    #
+    # The `window_bits` sets the size of the history buffer and should be between 8
+    # and 15.  Larger values of this parameter result in better compression at the
+    # expense of memory usage.
+    #
+    # The `mem_level` specifies how much memory should be allocated for the internal
+    # compression state.  1 uses minimum memory but is slow and reduces compression
+    # ratio while 9 uses maximum memory for optimal speed.  The default value is 8.
+    # Two constants are defined:
+    #
+    # *   Zlib::DEF_MEM_LEVEL
+    # *   Zlib::MAX_MEM_LEVEL
+    #
+    # The `strategy` sets the deflate compression strategy.  The following
+    # strategies are available:
+    #
+    # Zlib::DEFAULT_STRATEGY
+    # :   For normal data
+    #
+    # Zlib::FILTERED
+    # :   For data produced by a filter or predictor
+    #
+    # Zlib::FIXED
+    # :   Prevents dynamic Huffman codes
+    #
+    # Zlib::HUFFMAN_ONLY
+    # :   Prevents string matching
+    #
+    # Zlib::RLE
+    # :   Designed for better compression of PNG image data
+    #
+    #
+    # See the constants for further description.
+    #
+    # ## Examples
+    #
+    # ### Basic
+    #
+    #     open "compressed.file", "w+" do |io|
+    #       io << Zlib::Deflate.new.deflate(File.read("big.file"))
+    #     end
+    #
+    # ### Custom compression
+    #
+    #     open "compressed.file", "w+" do |compressed_io|
+    #       deflate = Zlib::Deflate.new(Zlib::BEST_COMPRESSION,
+    #                                   Zlib::MAX_WBITS,
+    #                                   Zlib::MAX_MEM_LEVEL,
+    #                                   Zlib::HUFFMAN_ONLY)
+    #
+    #       begin
+    #         open "big.file" do |big_io|
+    #           until big_io.eof? do
+    #             compressed_io << zd.deflate(big_io.read(16384))
+    #           end
+    #         end
+    #       ensure
+    #         deflate.close
+    #       end
+    #     end
+    #
+    # While this example will work, for best optimization review the flags for your
+    # specific time, memory usage and output space requirements.
+    #
+    def initialize: (?compression_level level, ?Integer window_bits, ?Integer mem_level, ?Integer strategy) -> void
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - initialize_copy(p1)
+    # -->
+    # Duplicates the deflate stream.
+    #
+    def initialize_copy: (self other) -> self
+  end
+end

data/stdlib/zlib/0/error.rbs

@@ -0,0 +1,20 @@
+%a{annotate:rdoc:skip}
+module Zlib
+  # <!-- rdoc-file=ext/zlib/zlib.c -->
+  # The superclass for all exceptions raised by Ruby/zlib.
+  #
+  # The following exceptions are defined as subclasses of Zlib::Error. These
+  # exceptions are raised when zlib library functions return with an error status.
+  #
+  # *   Zlib::StreamEnd
+  # *   Zlib::NeedDict
+  # *   Zlib::DataError
+  # *   Zlib::StreamError
+  # *   Zlib::MemError
+  # *   Zlib::BufError
+  # *   Zlib::VersionError
+  # *   Zlib::InProgressError
+  #
+  class Error < StandardError
+  end
+end

data/stdlib/zlib/0/gzip_file/crc_error.rbs

@@ -0,0 +1,12 @@
+%a{annotate:rdoc:skip}
+module Zlib
+  %a{annotate:rdoc:skip}
+  class GzipFile
+    # <!-- rdoc-file=ext/zlib/zlib.c -->
+    # Raised when the CRC checksum recorded in gzip file footer is not equivalent to
+    # the CRC checksum of the actual uncompressed data.
+    #
+    class CRCError < Zlib::GzipFile::Error
+    end
+  end
+end

data/stdlib/zlib/0/gzip_file/error.rbs

@@ -0,0 +1,23 @@
+%a{annotate:rdoc:skip}
+module Zlib
+  %a{annotate:rdoc:skip}
+  class GzipFile
+    # <!-- rdoc-file=ext/zlib/zlib.c -->
+    # Base class of errors that occur when processing GZIP files.
+    #
+    class Error < Zlib::Error
+      # <!-- rdoc-file=ext/zlib/zlib.c -->
+      # input gzipped string
+      #
+      def input: () -> String
+
+      # <!--
+      #   rdoc-file=ext/zlib/zlib.c
+      #   - inspect()
+      # -->
+      # Constructs a String of the GzipFile Error
+      #
+      def inspect: () -> String
+    end
+  end
+end

data/stdlib/zlib/0/gzip_file/length_error.rbs

@@ -0,0 +1,12 @@
+%a{annotate:rdoc:skip}
+module Zlib
+  %a{annotate:rdoc:skip}
+  class GzipFile
+    # <!-- rdoc-file=ext/zlib/zlib.c -->
+    # Raised when the data length recorded in the gzip file footer is not equivalent
+    # to the length of the actual uncompressed data.
+    #
+    class LengthError < Zlib::GzipFile::Error
+    end
+  end
+end

data/stdlib/zlib/0/gzip_file/no_footer.rbs

@@ -0,0 +1,11 @@
+%a{annotate:rdoc:skip}
+module Zlib
+  %a{annotate:rdoc:skip}
+  class GzipFile
+    # <!-- rdoc-file=ext/zlib/zlib.c -->
+    # Raised when gzip file footer is not found.
+    #
+    class NoFooter < Zlib::GzipFile::Error
+    end
+  end
+end

data/stdlib/zlib/0/gzip_file.rbs

@@ -0,0 +1,156 @@
+%a{annotate:rdoc:skip}
+module Zlib
+  # <!-- rdoc-file=ext/zlib/zlib.c -->
+  # Zlib::GzipFile is an abstract class for handling a gzip formatted compressed
+  # file. The operations are defined in the subclasses, Zlib::GzipReader for
+  # reading, and Zlib::GzipWriter for writing.
+  #
+  # GzipReader should be used by associating an IO, or IO-like, object.
+  #
+  # ## Method Catalogue
+  #
+  # *   ::wrap
+  # *   ::open (Zlib::GzipReader::open and Zlib::GzipWriter::open)
+  # *   #close
+  # *   #closed?
+  # *   #comment
+  # *   comment= (Zlib::GzipWriter#comment=)
+  # *   #crc
+  # *   eof? (Zlib::GzipReader#eof?)
+  # *   #finish
+  # *   #level
+  # *   lineno (Zlib::GzipReader#lineno)
+  # *   lineno= (Zlib::GzipReader#lineno=)
+  # *   #mtime
+  # *   mtime= (Zlib::GzipWriter#mtime=)
+  # *   #orig_name
+  # *   orig_name (Zlib::GzipWriter#orig_name=)
+  # *   #os_code
+  # *   path (when the underlying IO supports #path)
+  # *   #sync
+  # *   #sync=
+  # *   #to_io
+  #
+  # (due to internal structure, documentation may appear under Zlib::GzipReader or
+  # Zlib::GzipWriter)
+  #
+  class GzipFile
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - Zlib::GzipReader.wrap(io, ...) { |gz| ... }
+    #   - Zlib::GzipWriter.wrap(io, ...) { |gz| ... }
+    # -->
+    # Creates a GzipReader or GzipWriter associated with `io`, passing in any
+    # necessary extra options, and executes the block with the newly created object
+    # just like File.open.
+    #
+    # The GzipFile object will be closed automatically after executing the block. If
+    # you want to keep the associated IO object open, you may call
+    # Zlib::GzipFile#finish method in the block.
+    #
+    def self.wrap: (IO io, *untyped) { (instance gz) -> void } -> void
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - close()
+    # -->
+    # Closes the GzipFile object. This method calls close method of the associated
+    # IO object. Returns the associated IO object.
+    #
+    def close: () -> void
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - closed?()
+    # -->
+    # Same as IO#closed?
+    #
+    def closed?: () -> void
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - comment()
+    # -->
+    # Returns comments recorded in the gzip file header, or nil if the comments is
+    # not present.
+    #
+    def comment: () -> String?
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - crc()
+    # -->
+    # Returns CRC value of the uncompressed data.
+    #
+    def crc: () -> Integer
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - finish()
+    # -->
+    # Closes the GzipFile object. Unlike Zlib::GzipFile#close, this method never
+    # calls the close method of the associated IO object. Returns the associated IO
+    # object.
+    #
+    def finish: () -> IO
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - level()
+    # -->
+    # Returns compression level.
+    #
+    def level: () -> Integer
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - mtime()
+    # -->
+    # Returns last modification time recorded in the gzip file header.
+    #
+    def mtime: () -> Time
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - orig_name()
+    # -->
+    # Returns original filename recorded in the gzip file header, or `nil` if
+    # original filename is not present.
+    #
+    def orig_name: () -> String?
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - os_code()
+    # -->
+    # Returns OS code number recorded in the gzip file header.
+    #
+    def os_code: () -> Integer
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - sync()
+    # -->
+    # Same as IO#sync
+    #
+    def sync: () -> bool
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - sync = flag
+    # -->
+    # Same as IO.  If flag is `true`, the associated IO object must respond to the
+    # `flush` method.  While `sync` mode is `true`, the compression ratio decreases
+    # sharply.
+    #
+    def sync=: (boolish) -> untyped
+
+    # <!--
+    #   rdoc-file=ext/zlib/zlib.c
+    #   - to_io()
+    # -->
+    # Same as IO.
+    #
+    def to_io: () -> IO
+  end
+end