deflate-ruby 1.0.1 → 1.0.2

data/ext/deflate_ruby/libdeflate/README.md

@@ -1,228 +0,0 @@
-# Overview
-
-libdeflate is a library for fast, whole-buffer DEFLATE-based compression and
-decompression.
-
-The supported formats are:
-
-- DEFLATE (raw)
-- zlib (a.k.a. DEFLATE with a zlib wrapper)
-- gzip (a.k.a. DEFLATE with a gzip wrapper)
-
-libdeflate is heavily optimized.  It is significantly faster than the zlib
-library, both for compression and decompression, and especially on x86 and ARM
-processors.  In addition, libdeflate provides optional high compression modes
-that provide a better compression ratio than the zlib's "level 9".
-
-libdeflate itself is a library.  The following command-line programs which use
-this library are also included:
-
-* `libdeflate-gzip`, a program which can be a drop-in replacement for standard
-  `gzip` under some circumstances.  Note that `libdeflate-gzip` has some
-  limitations; it is provided for convenience and is **not** meant to be the
-  main use case of libdeflate.  It needs a lot of memory to process large files,
-  and it omits support for some infrequently-used options of GNU gzip.
-
-* `benchmark`, a test program that does round-trip compression and decompression
-  of the provided data, and measures the compression and decompression speed.
-  It can use libdeflate, zlib, or a combination of the two.
-
-* `checksum`, a test program that checksums the provided data with Adler-32 or
-  CRC-32, and optionally measures the speed.  It can use libdeflate or zlib.
-
-For the release notes, see the [NEWS file](NEWS.md).
-
-## Table of Contents
-
-- [Building](#building)
-  - [Using CMake](#using-cmake)
-  - [Directly integrating the library sources](#directly-integrating-the-library-sources)
-- [API](#api)
-- [Bindings for other programming languages](#bindings-for-other-programming-languages)
-- [DEFLATE vs. zlib vs. gzip](#deflate-vs-zlib-vs-gzip)
-- [Compression levels](#compression-levels)
-- [Motivation](#motivation)
-- [License](#license)
-
-# Building
-
-## Using CMake
-
-libdeflate uses [CMake](https://cmake.org/).  It can be built just like any
-other CMake project, e.g. with:
-
-    cmake -B build && cmake --build build
-
-By default the following targets are built:
-
-- The static library (normally called `libdeflate.a`)
-- The shared library (normally called `libdeflate.so`)
-- The `libdeflate-gzip` program, including its alias `libdeflate-gunzip`
-
-Besides the standard CMake build and installation options, there are some
-libdeflate-specific build options.  See `CMakeLists.txt` for the list of these
-options.  To set an option, add `-DOPTION=VALUE` to the `cmake` command.
-
-Prebuilt Windows binaries can be downloaded from
-https://github.com/ebiggers/libdeflate/releases.
-
-## Directly integrating the library sources
-
-Although the official build system is CMake, care has been taken to keep the
-library source files compilable directly, without a prerequisite configuration
-step.  Therefore, it is also fine to just add the library source files directly
-to your application, without using CMake.
-
-You should compile both `lib/*.c` and `lib/*/*.c`.  You don't need to worry
-about excluding irrelevant architecture-specific code, as this is already
-handled in the source files themselves using `#ifdef`s.
-
-If you are doing a freestanding build with `-ffreestanding`, you must add
-`-DFREESTANDING` as well (matching what the `CMakeLists.txt` does).
-
-## Supported compilers
-
-- gcc: v4.9 and later
-- clang: v3.9 and later (upstream), Xcode 8 and later (Apple)
-- MSVC: Visual Studio 2015 and later
-- Other compilers: any other C99-compatible compiler should work, though if your
-  compiler pretends to be gcc, clang, or MSVC, it needs to be sufficiently
-  compatible with the compiler it pretends to be.
-
-The above are the minimums, but using a newer compiler allows more of the
-architecture-optimized code to be built.  libdeflate is most heavily optimized
-for gcc and clang, but MSVC is supported fairly well now too.
-
-The recommended optimization flag is `-O2`, and the `CMakeLists.txt` sets this
-for release builds.  `-O3` is fine too, but often `-O2` actually gives better
-results.  It's unnecessary to add flags such as `-mavx2` or `/arch:AVX2`, though
-you can do so if you want to.  Most of the relevant optimized functions are
-built regardless of such flags, and appropriate ones are selected at runtime.
-
-# API
-
-libdeflate has a simple API that is not zlib-compatible.  You can create
-compressors and decompressors and use them to compress or decompress buffers.
-See libdeflate.h for details.
-
-There is currently no support for streaming.  This has been considered, but it
-always significantly increases complexity and slows down fast paths.
-Unfortunately, at this point it remains a future TODO.  So: if your application
-compresses data in "chunks", say, less than 1 MB in size, then libdeflate is a
-great choice for you; that's what it's designed to do.  This is perfect for
-certain use cases such as transparent filesystem compression.  But if your
-application compresses large files as a single compressed stream, similarly to
-the `gzip` program, then libdeflate isn't for you.
-
-Note that with chunk-based compression, you generally should have the
-uncompressed size of each chunk stored outside of the compressed data itself.
-This enables you to allocate an output buffer of the correct size without
-guessing.  However, libdeflate's decompression routines do optionally provide
-the actual number of output bytes in case you need it.
-
-Windows developers: note that the calling convention of libdeflate.dll is
-"cdecl".  (libdeflate v1.4 through v1.12 used "stdcall" instead.)
-
-# Bindings for other programming languages
-
-The libdeflate project itself only provides a C library.  If you need to use
-libdeflate from a programming language other than C or C++, consider using the
-following bindings:
-
-* C#: [LibDeflate.NET](https://github.com/jzebedee/LibDeflate.NET)
-* Go: [go-libdeflate](https://github.com/4kills/go-libdeflate)
-* Java: [libdeflate-java](https://github.com/astei/libdeflate-java)
-* Julia: [LibDeflate.jl](https://github.com/jakobnissen/LibDeflate.jl)
-* Nim: [libdeflate-nim](https://github.com/gemesa/libdeflate-nim)
-* Perl: [Gzip::Libdeflate](https://github.com/benkasminbullock/gzip-libdeflate)
-* PHP: [ext-libdeflate](https://github.com/pmmp/ext-libdeflate)
-* Python: [deflate](https://github.com/dcwatson/deflate)
-* Ruby: [libdeflate-ruby](https://github.com/kaorimatz/libdeflate-ruby)
-* Rust: [libdeflater](https://github.com/adamkewley/libdeflater)
-
-Note: these are third-party projects which haven't necessarily been vetted by
-the authors of libdeflate.  Please direct all questions, bugs, and improvements
-for these bindings to their authors.
-
-Also, unfortunately many of these bindings bundle or pin an old version of
-libdeflate.  To avoid known issues in old versions and to improve performance,
-before using any of these bindings please ensure that the bundled or pinned
-version of libdeflate has been upgraded to the latest release.
-
-# DEFLATE vs. zlib vs. gzip
-
-The DEFLATE format ([rfc1951](https://www.ietf.org/rfc/rfc1951.txt)), the zlib
-format ([rfc1950](https://www.ietf.org/rfc/rfc1950.txt)), and the gzip format
-([rfc1952](https://www.ietf.org/rfc/rfc1952.txt)) are commonly confused with
-each other as well as with the [zlib software library](http://zlib.net), which
-actually supports all three formats.  libdeflate (this library) also supports
-all three formats.
-
-Briefly, DEFLATE is a raw compressed stream, whereas zlib and gzip are different
-wrappers for this stream.  Both zlib and gzip include checksums, but gzip can
-include extra information such as the original filename.  Generally, you should
-choose a format as follows:
-
-- If you are compressing whole files with no subdivisions, similar to the `gzip`
-  program, you probably should use the gzip format.
-- Otherwise, if you don't need the features of the gzip header and footer but do
-  still want a checksum for corruption detection, you probably should use the
-  zlib format.
-- Otherwise, you probably should use raw DEFLATE.  This is ideal if you don't
-  need checksums, e.g. because they're simply not needed for your use case or
-  because you already compute your own checksums that are stored separately from
-  the compressed stream.
-
-Note that gzip and zlib streams can be distinguished from each other based on
-their starting bytes, but this is not necessarily true of raw DEFLATE streams.
-
-# Compression levels
-
-An often-underappreciated fact of compression formats such as DEFLATE is that
-there are an enormous number of different ways that a given input could be
-compressed.  Different algorithms and different amounts of computation time will
-result in different compression ratios, while remaining equally compatible with
-the decompressor.
-
-For this reason, the commonly used zlib library provides nine compression
-levels.  Level 1 is the fastest but provides the worst compression; level 9
-provides the best compression but is the slowest.  It defaults to level 6.
-libdeflate uses this same design but is designed to improve on both zlib's
-performance *and* compression ratio at every compression level.  In addition,
-libdeflate's levels go [up to 12](https://xkcd.com/670/) to make room for a
-minimum-cost-path based algorithm (sometimes called "optimal parsing") that can
-significantly improve on zlib's compression ratio.
-
-If you are using DEFLATE (or zlib, or gzip) in your application, you should test
-different levels to see which works best for your application.
-
-# Motivation
-
-Despite DEFLATE's widespread use mainly through the zlib library, in the
-compression community this format from the early 1990s is often considered
-obsolete.  And in a few significant ways, it is.
-
-So why implement DEFLATE at all, instead of focusing entirely on
-bzip2/LZMA/xz/LZ4/LZX/ZSTD/Brotli/LZHAM/LZFSE/[insert cool new format here]?
-
-To do something better, you need to understand what came before.  And it turns
-out that most ideas from DEFLATE are still relevant.  Many of the newer formats
-share a similar structure as DEFLATE, with different tweaks.  The effects of
-trivial but very useful tweaks, such as increasing the sliding window size, are
-often confused with the effects of nontrivial but less useful tweaks.  And
-actually, many of these formats are similar enough that common algorithms and
-optimizations (e.g. those dealing with LZ77 matchfinding) can be reused.
-
-In addition, comparing compressors fairly is difficult because the performance
-of a compressor depends heavily on optimizations which are not intrinsic to the
-compression format itself.  In this respect, the zlib library sometimes compares
-poorly to certain newer code because zlib is not well optimized for modern
-processors.  libdeflate addresses this by providing an optimized DEFLATE
-implementation which can be used for benchmarking purposes.  And, of course,
-real applications can use it as well.
-
-# License
-
-libdeflate is [MIT-licensed](COPYING).
-
-I am not aware of any patents or patent applications relevant to libdeflate.

data/ext/deflate_ruby/libdeflate/libdeflate-config.cmake.in

@@ -1,3 +0,0 @@
-@PACKAGE_INIT@
-
-include("${CMAKE_CURRENT_LIST_DIR}/libdeflate-targets.cmake")

data/ext/deflate_ruby/libdeflate/libdeflate.pc.in

@@ -1,18 +0,0 @@
-prefix=@CMAKE_INSTALL_PREFIX@
-exec_prefix=${prefix}
-includedir=@CMAKE_PKGCONFIG_INCLUDEDIR@
-libdir=@CMAKE_PKGCONFIG_LIBDIR@
-
-Name: libdeflate
-Description: Fast implementation of DEFLATE, zlib, and gzip
-Version: @PROJECT_VERSION@
-Libs: -L${libdir} -ldeflate
-Cflags: -I${includedir}
-
-# Note: this library's public header allows LIBDEFLATE_DLL to be defined when
-# linking to the DLL on Windows, to make __declspec(dllimport) be used.
-# However, the only way to define a shared-library-only flag in a pkgconfig file
-# is to use the weird workaround of unconditionally defining it in Cflags, then
-# undefining it in Cflags.private.  Just don't bother with this, since
-# __declspec(dllimport) is optional anyway.  It is a very minor performance
-# optimization that is irrelevant for most use cases of libdeflate.

data/ext/deflate_ruby/libdeflate/programs/CMakeLists.txt

@@ -1,105 +0,0 @@
-include(CheckSymbolExists)
-
-# Check for the availability of OS functionality and generate the config.h file.
-#
-# Keep CMAKE_REQUIRED_DEFINITIONS in sync with what prog_util.h does.
-if(LINUX)
-    set(CMAKE_REQUIRED_DEFINITIONS -D_GNU_SOURCE -D_POSIX_C_SOURCE=200809L)
-elseif(APPLE)
-    set(CMAKE_REQUIRED_DEFINITIONS -D_DARWIN_C_SOURCE -U_POSIX_C_SOURCE)
-else()
-    set(CMAKE_REQUIRED_DEFINITIONS -U_POSIX_C_SOURCE)
-endif()
-check_symbol_exists(clock_gettime "time.h" HAVE_CLOCK_GETTIME)
-check_symbol_exists(futimens "fcntl.h;sys/stat.h" HAVE_FUTIMENS)
-check_symbol_exists(posix_fadvise "fcntl.h" HAVE_POSIX_FADVISE)
-check_symbol_exists(posix_madvise "sys/mman.h" HAVE_POSIX_MADVISE)
-check_c_source_compiles("#include <sys/types.h>
-                         #include <sys/stat.h>
-                         int main() { struct stat st; (void)st.st_atim; }"
-                         HAVE_STAT_NANOSECOND_PRECISION)
-configure_file(config.h.in config.h)
-
-# Build a utility library for the programs.  This library is not installed.
-add_library(libdeflate_prog_utils STATIC prog_util.c tgetopt.c ../common_defs.h)
-set_target_properties(libdeflate_prog_utils PROPERTIES
-                      OUTPUT_NAME deflate_prog_utils)
-if(LIBDEFLATE_USE_SHARED_LIB)
-    target_link_libraries(libdeflate_prog_utils PUBLIC libdeflate_shared)
-else()
-    target_link_libraries(libdeflate_prog_utils PUBLIC libdeflate_static)
-endif()
-target_include_directories(libdeflate_prog_utils PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
-target_compile_definitions(libdeflate_prog_utils PUBLIC HAVE_CONFIG_H)
-if(WIN32)
-    if(MINGW)
-        target_compile_options(libdeflate_prog_utils PUBLIC -municode)
-        target_link_libraries(libdeflate_prog_utils PUBLIC -municode)
-    else()
-        target_compile_definitions(libdeflate_prog_utils PUBLIC UNICODE _UNICODE)
-    endif()
-endif()
-
-# Build and install libdeflate-gzip and its alias libdeflate-gunzip.
-if(LIBDEFLATE_BUILD_GZIP)
-    add_executable(libdeflate-gzip gzip.c)
-    target_link_libraries(libdeflate-gzip PRIVATE libdeflate_prog_utils)
-    install(TARGETS libdeflate-gzip DESTINATION ${CMAKE_INSTALL_BINDIR})
-    if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.14")
-        # Install libdeflate-gunzip as a hard link to libdeflate-gzip.
-        # Fall back to a copy if hard links are unsupported.
-        #
-        # Note: on Windows, prepending DESTDIR like this doesn't work correctly
-        # when ${CMAKE_INSTALL_FULL_BINDIR} includes a drive letter.  But that
-        # is fine since DESTDIR is unsupported on Windows anyway, according to
-        # the CMake documentation.
-        set(GZIP "${CMAKE_INSTALL_FULL_BINDIR}/libdeflate-gzip${CMAKE_EXECUTABLE_SUFFIX}")
-        set(GUNZIP "${CMAKE_INSTALL_FULL_BINDIR}/libdeflate-gunzip${CMAKE_EXECUTABLE_SUFFIX}")
-        install(CODE "message(\"-- Installing: \$ENV{DESTDIR}${GUNZIP}\")")
-        install(CODE "file(CREATE_LINK \"\$ENV{DESTDIR}${GZIP}\"
-                           \"\$ENV{DESTDIR}${GUNZIP}\" COPY_ON_ERROR)")
-    else()
-        # The cmake version is too old to support file(CREATE_LINK).
-        # Just compile gzip.c again to build libdeflate-gunzip.
-        add_executable(libdeflate-gunzip gzip.c)
-        target_link_libraries(libdeflate-gunzip PRIVATE libdeflate_prog_utils)
-        install(TARGETS libdeflate-gunzip DESTINATION ${CMAKE_INSTALL_BINDIR})
-    endif()
-endif()
-
-# Build the test programs, if requested.
-if(LIBDEFLATE_BUILD_TESTS)
-
-    # The test programs depend on zlib for comparison tests.
-    find_package(ZLIB REQUIRED)
-
-    # Build a utility library for the test programs.
-    add_library(libdeflate_test_utils STATIC test_util.c)
-    set_target_properties(libdeflate_test_utils PROPERTIES
-                          OUTPUT_NAME deflate_test_utils)
-    target_link_libraries(libdeflate_test_utils PUBLIC
-                          libdeflate_prog_utils ZLIB::ZLIB)
-
-    # Build the benchmark and checksum programs.
-    add_executable(benchmark benchmark.c)
-    target_link_libraries(benchmark PRIVATE libdeflate_test_utils)
-    add_executable(checksum checksum.c)
-    target_link_libraries(checksum PRIVATE libdeflate_test_utils)
-
-    # Build the unit test programs and register them with CTest.
-    set(UNIT_TEST_PROGS
-        test_checksums
-        test_custom_malloc
-        test_incomplete_codes
-        test_invalid_streams
-        test_litrunlen_overflow
-        test_overread
-        test_slow_decompression
-        test_trailing_bytes
-    )
-    foreach(PROG ${UNIT_TEST_PROGS})
-        add_executable(${PROG} ${PROG}.c)
-        target_link_libraries(${PROG} PRIVATE libdeflate_test_utils)
-        add_test(NAME ${PROG} COMMAND ${PROG})
-    endforeach()
-endif()