multi_compress 0.6.0 → 0.6.1

data/lib/multi_compress/reader/buffer_operations.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module MultiCompress
+  class Reader
+    BUFFER_COMPACT_THRESHOLD = 64 * 1024
+
+    module BufferOperations
+      private
+
+      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.zero?
+
+        total = @buffer.bytesize
+        return unless @buffer_pos >= BUFFER_COMPACT_THRESHOLD && @buffer_pos * 2 >= total
+
+        @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 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
+      end
+    end
+
+    private_constant :BufferOperations
+  end
+end

data/lib/multi_compress/reader/read_operations.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module MultiCompress
+  class Reader
+    module ReadOperations
+      private
+
+      def read_all
+        return nil if @eof && buffer_empty?
+
+        result = consume_buffer
+        result = +"".b if result.empty?
+        append_remaining_stream(result)
+        result.empty? ? nil : result
+      end
+
+      def append_remaining_stream(result)
+        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?
+      end
+
+      def read_exactly(length)
+        return nil if @eof && buffer_empty?
+
+        fill_buffer_until { buffer_size >= length }
+        return read_buffer_slice(length) if buffer_size >= length
+
+        consume_buffer unless buffer_empty?
+      end
+
+      def read_buffer_slice(length)
+        result = @buffer.byteslice(@buffer_pos, length)
+        @buffer_pos += length
+        compact_buffer_if_needed
+        result
+      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 read_compressed_chunk
+        @io.read(CHUNK_SIZE)
+      rescue EOFError
+        nil
+      end
+    end
+
+    private_constant :ReadOperations
+  end
+end

data/lib/multi_compress/reader.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module MultiCompress
+  class Reader
+    CHUNK_SIZE = 8192
+    require "multi_compress/reader/buffer_operations"
+    require "multi_compress/reader/read_operations"
+    include BufferOperations
+    include ReadOperations
+
+    def self.open(path_or_io, algo: nil, dictionary: nil, **opts, &block)
+      io, algo, owned = StreamIO.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
+    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
+    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
+    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
+      end
+    end
+
+    def readline
+      gets || raise(EOFError, "end of file reached")
+    end
+
+    private
+
+    def ensure_open!
+      raise StreamError, "reader is closed" if @closed
+    end
+  end
+end

data/lib/multi_compress/stream_io.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module MultiCompress
+  module StreamIO
+    module_function
+
+    def resolve_io(path_or_io, algo, mode:)
+      return [path_or_io, algo, false] unless path_or_io.is_a?(String)
+
+      [File.open(path_or_io, mode), algo || MultiCompress.algo_from_ext(path_or_io), true]
+    end
+  end
+end

data/lib/multi_compress/version.rb

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

data/lib/multi_compress/writer.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module MultiCompress
+  class Writer
+    CHUNK_BUFFER_SIZE = 8192
+
+    def self.open(path_or_io, algo: nil, level: nil, dictionary: nil, &block)
+      io, algo, owned = StreamIO.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.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
+  end
+end