multi_compress 0.1.0

data/ext/multi_compress/vendor/zstd/lib/zstd_errors.h

@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#ifndef ZSTD_ERRORS_H_398273423
+#define ZSTD_ERRORS_H_398273423
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/*===== dependency =====*/
+#include <stddef.h>   /* size_t */
+
+
+/* =====   ZSTDERRORLIB_API : control library symbols visibility   ===== */
+#ifndef ZSTDERRORLIB_VISIBLE
+   /* Backwards compatibility with old macro name */
+#  ifdef ZSTDERRORLIB_VISIBILITY
+#    define ZSTDERRORLIB_VISIBLE ZSTDERRORLIB_VISIBILITY
+#  elif defined(__GNUC__) && (__GNUC__ >= 4) && !defined(__MINGW32__)
+#    define ZSTDERRORLIB_VISIBLE __attribute__ ((visibility ("default")))
+#  else
+#    define ZSTDERRORLIB_VISIBLE
+#  endif
+#endif
+
+#ifndef ZSTDERRORLIB_HIDDEN
+#  if defined(__GNUC__) && (__GNUC__ >= 4) && !defined(__MINGW32__)
+#    define ZSTDERRORLIB_HIDDEN __attribute__ ((visibility ("hidden")))
+#  else
+#    define ZSTDERRORLIB_HIDDEN
+#  endif
+#endif
+
+#if defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1)
+#  define ZSTDERRORLIB_API __declspec(dllexport) ZSTDERRORLIB_VISIBLE
+#elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1)
+#  define ZSTDERRORLIB_API __declspec(dllimport) ZSTDERRORLIB_VISIBLE /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
+#else
+#  define ZSTDERRORLIB_API ZSTDERRORLIB_VISIBLE
+#endif
+
+/*-*********************************************
+ *  Error codes list
+ *-*********************************************
+ *  Error codes _values_ are pinned down since v1.3.1 only.
+ *  Therefore, don't rely on values if you may link to any version < v1.3.1.
+ *
+ *  Only values < 100 are considered stable.
+ *
+ *  note 1 : this API shall be used with static linking only.
+ *           dynamic linking is not yet officially supported.
+ *  note 2 : Prefer relying on the enum than on its value whenever possible
+ *           This is the only supported way to use the error list < v1.3.1
+ *  note 3 : ZSTD_isError() is always correct, whatever the library version.
+ **********************************************/
+typedef enum {
+  ZSTD_error_no_error = 0,
+  ZSTD_error_GENERIC  = 1,
+  ZSTD_error_prefix_unknown                = 10,
+  ZSTD_error_version_unsupported           = 12,
+  ZSTD_error_frameParameter_unsupported    = 14,
+  ZSTD_error_frameParameter_windowTooLarge = 16,
+  ZSTD_error_corruption_detected = 20,
+  ZSTD_error_checksum_wrong      = 22,
+  ZSTD_error_literals_headerWrong = 24,
+  ZSTD_error_dictionary_corrupted      = 30,
+  ZSTD_error_dictionary_wrong          = 32,
+  ZSTD_error_dictionaryCreation_failed = 34,
+  ZSTD_error_parameter_unsupported   = 40,
+  ZSTD_error_parameter_combination_unsupported = 41,
+  ZSTD_error_parameter_outOfBound    = 42,
+  ZSTD_error_tableLog_tooLarge       = 44,
+  ZSTD_error_maxSymbolValue_tooLarge = 46,
+  ZSTD_error_maxSymbolValue_tooSmall = 48,
+  ZSTD_error_stabilityCondition_notRespected = 50,
+  ZSTD_error_stage_wrong       = 60,
+  ZSTD_error_init_missing      = 62,
+  ZSTD_error_memory_allocation = 64,
+  ZSTD_error_workSpace_tooSmall= 66,
+  ZSTD_error_dstSize_tooSmall = 70,
+  ZSTD_error_srcSize_wrong    = 72,
+  ZSTD_error_dstBuffer_null   = 74,
+  ZSTD_error_noForwardProgress_destFull = 80,
+  ZSTD_error_noForwardProgress_inputEmpty = 82,
+  /* following error codes are __NOT STABLE__, they can be removed or changed in future versions */
+  ZSTD_error_frameIndex_tooLarge = 100,
+  ZSTD_error_seekableIO          = 102,
+  ZSTD_error_dstBuffer_wrong     = 104,
+  ZSTD_error_srcBuffer_wrong     = 105,
+  ZSTD_error_sequenceProducer_failed = 106,
+  ZSTD_error_externalSequences_invalid = 107,
+  ZSTD_error_maxCode = 120  /* never EVER use this value directly, it can change in future versions! Use ZSTD_isError() instead */
+} ZSTD_ErrorCode;
+
+/*! ZSTD_getErrorCode() :
+    convert a `size_t` function result into a `ZSTD_ErrorCode` enum type,
+    which can be used to compare with enum list published above */
+ZSTDERRORLIB_API ZSTD_ErrorCode ZSTD_getErrorCode(size_t functionResult);
+ZSTDERRORLIB_API const char* ZSTD_getErrorString(ZSTD_ErrorCode code);   /**< Same as ZSTD_getErrorName, but using a `ZSTD_ErrorCode` enum argument */
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* ZSTD_ERRORS_H_398273423 */

data/lib/multi_compress/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MultiCompress
+  VERSION = "0.1.0"
+end

data/lib/multi_compress.rb

@@ -0,0 +1,329 @@
+# frozen_string_literal: true
+
+require "multi_compress/version"
+
+begin
+  require "multi_compress/multi_compress"
+rescue LoadError
+  ext_dir = File.expand_path("../multi_compress", __FILE__)
+
+  so_path = %w[.bundle .so]
+    .map { |ext| File.join(ext_dir, "multi_compress#{ext}") }
+    .find { |path| File.exist?(path) }
+
+  raise LoadError, "Could not find compiled MultiCompress extension. Run: bundle exec rake compile" unless so_path
+
+  require so_path
+end
+
+module MultiCompress
+  FASTEST = :fastest
+  DEFAULT = :default
+  BEST    = :best
+
+  EXTENSION_MAP = {
+    ".zst"  => :zstd,
+    ".zstd" => :zstd,
+    ".lz4"  => :lz4,
+    ".br"   => :brotli,
+  }.freeze
+
+  private_constant :EXTENSION_MAP
+
+  def self.zstd(data, level: nil)
+    compress(data, algo: :zstd, **level_opts(level))
+  end
+
+  def self.lz4(data, level: nil)
+    compress(data, algo: :lz4, **level_opts(level))
+  end
+
+  def self.brotli(data, level: nil)
+    compress(data, algo: :brotli, **level_opts(level))
+  end
+
+  def self.zstd_decompress(data)
+    decompress(data, algo: :zstd)
+  end
+
+  def self.lz4_decompress(data)
+    decompress(data, algo: :lz4)
+  end
+
+  def self.brotli_decompress(data)
+    decompress(data, algo: :brotli)
+  end
+
+  def self.algo_from_ext(path)
+    EXTENSION_MAP[File.extname(path).downcase]
+  end
+
+  def self.level_opts(level)
+    level ? { level: level } : {}
+  end
+
+  private_class_method :level_opts
+
+  # Streaming compressed writer.
+  #
+  # Supports block form via +Writer.open+ or manual lifecycle management.
+  class Writer
+    CHUNK_BUFFER_SIZE = 8192
+
+    def self.open(path_or_io, algo: nil, level: nil, dictionary: nil, &block)
+      io, algo, owned = resolve_io(path_or_io, algo, mode: "wb")
+      writer = new(io, algo: algo || :zstd, level: level, dictionary: dictionary)
+      writer.instance_variable_set(:@owned_io, owned)
+
+      return writer unless block
+
+      begin
+        yield writer
+      ensure
+        writer.close
+      end
+    end
+
+    def initialize(io, algo: :zstd, level: nil, dictionary: nil)
+      @io       = io
+      @deflater = Deflater.new(algo: algo, level: level, dictionary: dictionary)
+      @closed   = false
+      @owned_io = false
+    end
+
+    def write(data)
+      ensure_open!
+      bytes = data.to_s
+      flush_compressed(@deflater.write(bytes))
+      bytes.bytesize
+    end
+
+    def flush
+      ensure_open!
+      flush_compressed(@deflater.flush)
+      @io.flush if @io.respond_to?(:flush)
+      self
+    end
+
+    def close
+      return if @closed
+
+      flush_compressed(@deflater.finish)
+      @deflater.close
+      @io.close if @owned_io && @io.respond_to?(:close)
+      @closed = true
+      nil
+    end
+
+    def closed?
+      @closed
+    end
+
+    def <<(data)
+      write(data)
+      self
+    end
+
+    def puts(*args)
+      args.each do |arg|
+        str = arg.to_s
+        write(str)
+        write("\n") unless str.end_with?("\n")
+      end
+      nil
+    end
+
+    def print(*args)
+      args.each { |arg| write(arg.to_s) }
+      nil
+    end
+
+    private
+
+    def ensure_open!
+      raise StreamError, "writer is closed" if @closed
+    end
+
+    def flush_compressed(compressed)
+      @io.write(compressed) if compressed && !compressed.empty?
+    end
+
+    def self.resolve_io(path_or_io, algo, mode:)
+      if path_or_io.is_a?(String)
+        [File.open(path_or_io, mode), algo || MultiCompress.algo_from_ext(path_or_io), true]
+      else
+        [path_or_io, algo, false]
+      end
+    end
+
+    private_class_method :resolve_io
+  end
+
+  # Streaming compressed reader.
+  #
+  # Supports block form via +Reader.open+ or manual lifecycle management.
+  class Reader
+    CHUNK_SIZE = 8192
+
+    def self.open(path_or_io, algo: nil, dictionary: nil, &block)
+      io, algo, owned = resolve_io(path_or_io, algo, mode: "rb")
+      reader = new(io, algo: algo, dictionary: dictionary)
+      reader.instance_variable_set(:@owned_io, owned)
+
+      return reader unless block
+
+      begin
+        yield reader
+      ensure
+        reader.close
+      end
+    end
+
+    def initialize(io, algo: nil, dictionary: nil)
+      @io       = io
+      @inflater = Inflater.new(algo: algo, dictionary: dictionary)
+      @closed   = false
+      @owned_io = false
+      @buffer   = +""
+      @eof      = false
+    end
+
+    def read(length = nil)
+      ensure_open!
+      return read_all if length.nil?
+
+      read_exactly(length)
+    end
+
+    def gets(separator = "\n")
+      ensure_open!
+      return nil if @eof && @buffer.empty?
+
+      fill_buffer_until { @buffer.include?(separator) }
+
+      return extract_line(separator) if @buffer.include?(separator)
+      return consume_buffer unless @buffer.empty?
+
+      nil
+    end
+
+    def close
+      return if @closed
+
+      @inflater.close
+      @io.close if @owned_io && @io.respond_to?(:close)
+      @closed = true
+      nil
+    end
+
+    def closed?
+      @closed
+    end
+
+    def eof?
+      @eof && @buffer.empty?
+    end
+
+    def each_line
+      return enum_for(:each_line) unless block_given?
+
+      while (line = gets)
+        yield line
+      end
+    end
+
+    def each_chunk(size)
+      return enum_for(:each_chunk, size) unless block_given?
+
+      while (chunk = read(size))
+        yield chunk
+        break if chunk.bytesize < size
+      end
+    end
+
+    def readline
+      gets || raise(EOFError, "end of file reached")
+    end
+
+    private
+
+    def ensure_open!
+      raise StreamError, "reader is closed" if @closed
+    end
+
+    def read_all
+      return nil if @eof && @buffer.empty?
+
+      result = @buffer.dup
+      @buffer.clear
+
+      until @eof
+        chunk = read_compressed_chunk
+        break unless chunk && !chunk.empty?
+
+        decompressed = @inflater.write(chunk)
+        result << decompressed if decompressed
+      end
+
+      final = @inflater.finish
+      result << final if final && !final.empty?
+
+      result.empty? ? nil : result
+    end
+
+    def read_exactly(length)
+      return +("") if @eof && @buffer.empty?
+
+      fill_buffer_until { @buffer.bytesize >= length }
+
+      if @buffer.bytesize >= length
+        result  = @buffer[0, length]
+        @buffer = @buffer[length..]
+        result
+      elsif !@buffer.empty?
+        consume_buffer
+      end
+    end
+
+    def fill_buffer_until
+      until yield || @eof
+        chunk = read_compressed_chunk
+        if chunk.nil? || chunk.empty?
+          @eof = true
+          break
+        end
+        decompressed = @inflater.write(chunk)
+        @buffer << decompressed if decompressed
+      end
+    end
+
+    def extract_line(separator)
+      idx    = @buffer.index(separator)
+      result = @buffer[0..idx]
+      @buffer = @buffer[(idx + 1)..]
+      result
+    end
+
+    def consume_buffer
+      result  = @buffer
+      @buffer = +""
+      result
+    end
+
+    def read_compressed_chunk
+      @io.read(CHUNK_SIZE)
+    rescue EOFError
+      nil
+    end
+
+    def self.resolve_io(path_or_io, algo, mode:)
+      if path_or_io.is_a?(String)
+        [File.open(path_or_io, mode), algo || MultiCompress.algo_from_ext(path_or_io), true]
+      else
+        [path_or_io, algo, false]
+      end
+    end
+
+    private_class_method :resolve_io
+  end
+end