(Ruby) Streaming Compression

Compress and decompress using a stream.

Chilkat Ruby Downloads install from rubygems.org gem install chilkat or download... Ruby Library for Windows, MacOS, Linux, Alpine Linux

require 'chilkat'

# This example assumes the Chilkat API to have been previously unlocked.
# See Global Unlock Sample for sample code.

fac = Chilkat::CkFileAccess.new()
compress = Chilkat::CkCompression.new()
compress.put_Algorithm("deflate")

streamC = Chilkat::CkStream.new()

# This example sets the source and sink of the stream to files.
# A stream can have use other streams as a source or sink,
# or the application can itself be the source/sink by directly
# reading or writing a stream.  (See below for an example of this..)
streamC.put_SourceFile("qa_data/hamlet.xml")
streamC.put_SinkFile("qa_output/hamlet_compressed.dat")

# Compress from source to sink.
success = compress.CompressStream(streamC)
if (success != true)
    print compress.lastErrorText() + "\n";
    exit
end

print "File-to-file deflate compression successful." + "\n";
# Note: The FileSize method returns a signed 32-bit integer.  If the file is potentially larger than 2GB, call FileSizeStr instead to return
# the size of the file as a string, then convert to an integer value.
print "Original size = " + fac.FileSize(streamC.sourceFile()).to_s() + "\n";
print "Compressed size = " + fac.FileSize(streamC.sinkFile()).to_s() + "\n";

# Now do file-to-file decompression
streamD = Chilkat::CkStream.new()
streamD.put_SourceFile("qa_output/hamlet_compressed.dat")
streamD.put_SinkFile("qa_output/hamlet_restored.xml")

# Decompress from source to sink.
success = compress.DecompressStream(streamD)
if (success != true)
    print compress.lastErrorText() + "\n";
    exit
end

print "File-to-file deflate decompression successful." + "\n";

# Let's double-check to see that the files are equal in size and content:

bFilesEqual = fac.FileContentsEqual(streamC.sourceFile(),streamD.sinkFile())
if (bFilesEqual != true)
    print "The output file is not equal to the input file!" + "\n";
else
    print "The file was successfully compressed and decompressed." + "\n";
end

# ---------------------------------------------------------------------
# Now let's decompress again, but this time w/ the application reading
# the decompressed data directly from a stream.
streamA = Chilkat::CkStream.new()

streamA.put_SourceFile("qa_output/hamlet_compressed.dat")

# Start decompressing in a background thread.
# task is a CkTask
task = compress.DecompressStreamAsync(streamA)
success = task.Run()

# Read decompressed data from streamA:

while (streamA.get_EndOfStream() != true)
    if (streamA.get_DataAvailable() == true)
        decompressedText = streamA.readString()
        print decompressedText + "\n";
    end

end

# Let's make sure the background task finished and that the decompress was successful.
# It should already be the case that the task is finished.
while (task.get_Finished() != true)
    task.SleepMs(20)
end

# The decompressor may have finished, but it is possible that data
# remains to be flushed.  
if (streamA.get_DataAvailable() == true)
    decompressedText = streamA.readString()
    print decompressedText + "\n";
end

# Did streamA succeed in reading the entire file?
if (task.get_TaskSuccess() != true)
    print "async decompress failed:" + "\n";
    print task.resultErrorText() + "\n";
    success = false
end

print "The async decompress was successful." + "\n";