multi_compress 0.6.0 → 0.6.1

data/lib/multi_compress.rb

@@ -5,11 +5,11 @@ require "multi_compress/version"
 begin
   require "multi_compress/multi_compress"
 rescue LoadError
-  ext_dir = File.expand_path("../multi_compress", __FILE__)
+  ext_dir = File.expand_path("multi_compress", __dir__)
 
   so_path = %w[.bundle .so]
-    .map { |ext| File.join(ext_dir, "multi_compress#{ext}") }
-    .find { |path| File.exist?(path) }
+            .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
 
@@ -25,10 +25,10 @@ module MultiCompress
   DEFAULT_STREAMING_MAX_OUTPUT_SIZE = 2 * 1024 * 1024 * 1024
 
   EXTENSION_MAP = {
-    ".zst"  => :zstd,
+    ".zst" => :zstd,
     ".zstd" => :zstd,
-    ".lz4"  => :lz4,
-    ".br"   => :brotli,
+    ".lz4" => :lz4,
+    ".br" => :brotli
   }.freeze
 
   private_constant :EXTENSION_MAP
@@ -91,361 +91,70 @@ module MultiCompress
     end
 
     unless private_method_defined?(:_c_decompress)
-      alias_method :_c_decompress, :decompress
+      alias _c_decompress decompress
       private :_c_decompress
     end
-  end
-
-  def self.zstd(data, level: nil)
-    compress(data, algo: :zstd, level: level)
-  end
-
-  def self.lz4(data, level: nil, format: nil)
-    if format
-      compress(data, algo: :lz4, level: level, format: format)
-    else
-      compress(data, algo: :lz4, level: level)
-    end
-  end
-
-  def self.brotli(data, level: nil)
-    compress(data, algo: :brotli, level: level)
-  end
-
-  def self.decompress(data, **opts)
-    _c_decompress(data, **resolved_one_shot_options(opts))
-  end
-
-  def self.zstd_decompress(data)
-    decompress(data, algo: :zstd)
-  end
-
-  def self.lz4_decompress(data, format: nil)
-    if format
-      decompress(data, algo: :lz4, format: format)
-    else
-      decompress(data, algo: :lz4)
-    end
-  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.resolved_one_shot_options(opts)
-    return opts.merge(max_output_size: config.max_output_size) unless opts.key?(:max_output_size)
-
-    opts
-  end
-
-  private_class_method :resolved_one_shot_options
-
-  module InflaterDefaults
-    def initialize(*args, **opts)
-      resolved = opts.dup
-      resolved[:max_output_size] = MultiCompress.config.streaming_max_output_size unless resolved.key?(:max_output_size)
-      super(*args, **resolved)
-    end
-  end
-
-  Inflater.prepend(InflaterDefaults)
 
-  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
+    def zstd(data, level: nil)
+      compress(data, algo: :zstd, level: level)
     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.flatten.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]
+    def lz4(data, level: nil, format: nil)
+      if format
+        compress(data, algo: :lz4, level: level, format: format)
       else
-        [path_or_io, algo, false]
+        compress(data, algo: :lz4, level: level)
       end
     end
 
-    private_class_method :resolve_io
-  end
-
-  class Reader
-    CHUNK_SIZE = 8192
-    BUFFER_COMPACT_THRESHOLD = 64 * 1024
-
-    def self.open(path_or_io, algo: nil, dictionary: nil, **opts, &block)
-      io, algo, owned = resolve_io(path_or_io, algo, mode: "rb")
-      reader = new(io, algo: algo, dictionary: dictionary, **opts)
-      reader.instance_variable_set(:@owned_io, owned)
-
-      return reader unless block
-
-      begin
-        yield reader
-      ensure
-        reader.close
-      end
+    def brotli(data, level: nil)
+      compress(data, algo: :brotli, level: level)
     end
 
-    def initialize(io, algo: nil, dictionary: nil, **opts)
-      @io          = io
-      @inflater    = Inflater.new(algo: algo, dictionary: dictionary, **opts)
-      @closed      = false
-      @owned_io    = false
-      @buffer      = +"".b
-      @buffer_pos  = 0
-      @eof         = false
+    def decompress(data, **opts)
+      _c_decompress(data, **resolved_one_shot_options(opts))
     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_includes?(separator) }
-
-      return extract_line(separator) if buffer_includes?(separator)
-      return consume_buffer unless buffer_empty?
-
-      nil
+    def zstd_decompress(data)
+      decompress(data, algo: :zstd)
     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
+    def lz4_decompress(data, format: nil)
+      if format
+        decompress(data, algo: :lz4, format: format)
+      else
+        decompress(data, algo: :lz4)
       end
     end
 
-    def each_chunk(size)
-      return enum_for(:each_chunk, size) unless block_given?
-
-      while (chunk = read(size))
-        yield chunk
-      end
+    def brotli_decompress(data)
+      decompress(data, algo: :brotli)
     end
 
-    def readline
-      gets || raise(EOFError, "end of file reached")
+    def algo_from_ext(path)
+      EXTENSION_MAP[File.extname(path).downcase]
     end
 
     private
 
-    def ensure_open!
-      raise StreamError, "reader is closed" if @closed
-    end
-
-    def buffer_size
-      @buffer.bytesize - @buffer_pos
-    end
-
-    def buffer_empty?
-      @buffer_pos >= @buffer.bytesize
-    end
-
-    def buffer_append(data)
-      compact_buffer_if_needed
-      @buffer << data
-    end
-
-    def compact_buffer_if_needed
-      return if @buffer_pos == 0
-
-      total = @buffer.bytesize
-      return unless @buffer_pos >= BUFFER_COMPACT_THRESHOLD && @buffer_pos * 2 >= total
+    def resolved_one_shot_options(opts)
+      return opts.merge(max_output_size: config.max_output_size) unless opts.key?(:max_output_size)
 
-      @buffer = @buffer.byteslice(@buffer_pos, total - @buffer_pos)
-      @buffer_pos = 0
-    end
-
-    def buffer_includes?(separator)
-      idx = @buffer.index(separator, @buffer_pos)
-      !idx.nil?
-    end
-
-    def read_all
-      return nil if @eof && buffer_empty?
-
-      result = if buffer_empty?
-        +"".b
-      else
-        @buffer.byteslice(@buffer_pos, @buffer.bytesize - @buffer_pos) || +"".b
-      end
-      @buffer.clear
-      @buffer_pos = 0
-
-      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 nil if @eof && buffer_empty?
-
-      fill_buffer_until { buffer_size >= length }
-
-      if buffer_size >= length
-        result = @buffer.byteslice(@buffer_pos, length)
-        @buffer_pos += length
-        compact_buffer_if_needed
-        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_append(decompressed) if decompressed
-      end
-    end
-
-    def extract_line(separator)
-      idx = @buffer.index(separator, @buffer_pos)
-      end_pos = idx + separator.bytesize
-      result = @buffer.byteslice(@buffer_pos, end_pos - @buffer_pos)
-      @buffer_pos = end_pos
-      compact_buffer_if_needed
-      result
-    end
-
-    def consume_buffer
-      result = @buffer.byteslice(@buffer_pos, @buffer.bytesize - @buffer_pos) || +"".b
-      @buffer.clear
-      @buffer_pos = 0
-      result
+      opts
     end
+  end
 
-    def read_compressed_chunk
-      @io.read(CHUNK_SIZE)
-    rescue EOFError
-      nil
+  module InflaterDefaults
+    def initialize(*args, **opts)
+      resolved = opts.dup
+      resolved[:max_output_size] = MultiCompress.config.streaming_max_output_size unless resolved.key?(:max_output_size)
+      super(*args, **resolved)
     end
+  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
+  Inflater.prepend(InflaterDefaults)
 
-    private_class_method :resolve_io
-  end
+  require "multi_compress/stream_io"
+  require "multi_compress/writer"
+  require "multi_compress/reader"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: multi_compress
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Roman Haydarov
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-06 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -348,8 +347,30 @@ files:
 - lib/multi_compress/active_record.rb
 - lib/multi_compress/codec.rb
 - lib/multi_compress/database.rb
+- lib/multi_compress/database/api.rb
+- lib/multi_compress/database/decoding.rb
+- lib/multi_compress/database/dictionary.rb
+- lib/multi_compress/database/encoding.rb
+- lib/multi_compress/database/header.rb
+- lib/multi_compress/database/operations.rb
+- lib/multi_compress/database/validation.rb
 - lib/multi_compress/db_deployment.rb
+- lib/multi_compress/db_deployment/bundle_archiver.rb
+- lib/multi_compress/db_deployment/bundle_metadata.rb
+- lib/multi_compress/db_deployment/bundle_stager.rb
+- lib/multi_compress/db_deployment/commands.rb
+- lib/multi_compress/db_deployment/deployment_bundle.rb
+- lib/multi_compress/db_deployment/deterministic_tar_writer.rb
+- lib/multi_compress/db_deployment/dictionary_registry.rb
+- lib/multi_compress/db_deployment/readable_view.rb
+- lib/multi_compress/db_deployment/readable_view_options.rb
+- lib/multi_compress/db_deployment/sql_identifiers.rb
+- lib/multi_compress/reader.rb
+- lib/multi_compress/reader/buffer_operations.rb
+- lib/multi_compress/reader/read_operations.rb
+- lib/multi_compress/stream_io.rb
 - lib/multi_compress/version.rb
+- lib/multi_compress/writer.rb
 - multi_compress.gemspec
 - mysql_udf/Makefile
 - mysql_udf/README.md
@@ -381,7 +402,6 @@ metadata:
   homepage_uri: https://github.com/roman-haidarov/multi_compress
   source_code_uri: https://github.com/roman-haidarov/multi_compress
   changelog_uri: https://github.com/roman-haidarov/multi_compress/blob/main/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -396,8 +416,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.22
-signing_key:
+rubygems_version: 3.6.7
 specification_version: 4
 summary: 'Modern fiber-friendly compression for Ruby: zstd, lz4, brotli in one gem'
 test_files: []