ffi-zlib 0.2.0

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2010 Scott Chacon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,14 @@
+ffi-zlib
+========
+
+A ruby-ffi wrapper for the zlib library. 
+
+Installation
+============
+
+    [sudo] gem install ffi-zlib
+
+Usage
+=====
+
+ffi-zlib being a very thin wrapper roughly reproducing the zlib header(s), you can simply refer to the zlib [manual](http://www.zlib.net/manual.html) for details and usage. 

data/lib/ffi/zlib.rb

@@ -0,0 +1,213 @@
+# =============================================================================
+
+require "rubygems"
+require "ffi"
+
+# =============================================================================
+
+module FFI::Zlib
+    extend FFI::Library
+    ffi_lib("z")
+
+    # -------------------------------------------------------------------------
+
+    attach_function :zlibVersion, [ ], :string
+
+    # -------------------------------------------------------------------------
+
+    ZLIB_VERSION            = zlibVersion()
+
+    # Allowed flush values.
+
+    Z_NO_FLUSH              = 0
+    Z_PARTIAL_FLUSH         = 1
+    Z_SYNC_FLUSH            = 2
+    Z_FULL_FLUSH            = 3
+    Z_FINISH                = 4
+    Z_BLOCK                 = 5
+
+    # Return codes for the compression/decompression functions. 
+    # Negative values are errors, positive values are used for special but 
+    # normal events.
+
+    Z_OK                    = 0
+    Z_STREAM_END            = 1
+    Z_NEED_DICT             = 2
+    Z_ERRNO                 = -1
+    Z_STREAM_ERROR          = -2
+    Z_DATA_ERROR            = -3
+    Z_MEM_ERROR             = -4
+    Z_BUF_ERROR             = -5
+    Z_VERSION_ERROR         = -6
+    
+    # Compression levels.
+    
+    Z_NO_COMPRESSION        = 0
+    Z_BEST_SPEED            = 1
+    Z_BEST_COMPRESSION      = 9
+    Z_DEFAULT_COMPRESSION   = -1
+    
+    # Compression strategies.
+    
+    Z_FILTERED              = 1
+    Z_HUFFMAN_ONLY          = 2
+    Z_RLE                   = 3
+    Z_FIXED                 = 4
+    Z_DEFAULT_STRATEGY      = 0
+
+    # Possible values of the data_type field.
+
+    Z_BINARY                = 0
+    Z_TEXT                  = 1
+    Z_UNKNOWN               = 2
+
+    # The deflate compression method (the only one supported).
+
+    Z_DEFLATED              = 8
+
+    # -------------------------------------------------------------------------
+    
+    class Z_stream < FFI::Struct
+        layout  :next_in,       :pointer,
+                :avail_in,      :uint,
+                :total_in,      :ulong,
+                
+                :next_out,      :pointer,
+                :avail_out,     :uint,
+                :total_out,     :ulong,
+                
+                :msg,           :string,
+                :state,         :pointer,
+                
+                :alloc_func,    :pointer,
+                :free_func,     :pointer,
+                :opaque,        :pointer,
+                
+                :data_type,     :int,
+                :adler,         :ulong,
+                :reserved,      :ulong
+    end
+
+    # -------------------------------------------------------------------------
+
+    class GZ_header < FFI::Struct
+        layout  :text,          :int,
+                :time,          :ulong,
+                :xflags,        :int,
+                :os,            :int,
+
+                :extra,         :pointer,
+                :extra_len,     :uint,
+                :extra_max,     :uint,
+
+                :name,          :string,
+                :name_max,      :uint,
+                :comment,       :string,
+                :comm_max,      :uint,
+                
+                :hcrc,          :int,
+                :done,          :int
+    end
+
+    # -------------------------------------------------------------------------
+            
+    def self.deflateInit(zstream, level)
+        deflateInit_(zstream, level, ZLIB_VERSION, zstream.size)
+    end
+
+    def self.deflateInit2(zstream, level, method, window_bits, mem_level, strategy)
+        deflateInit2_(zstream, level, method, window_bits, mem_level, strategy, ZLIB_VERSION, zstream.size)
+    end
+
+    attach_function :deflateInit_, [:pointer, :int, :string, :int], :int
+    attach_function :deflateInit2_, [:pointer, :int, :int, :int, :int, :int, :string, :int], :int
+    attach_function :deflate, [:pointer, :int], :int
+    attach_function :deflateEnd, [:pointer], :int
+
+    attach_function :deflateSetDictionary, [:pointer, :pointer, :uint], :int
+    attach_function :deflateCopy, [:pointer, :pointer], :int
+    attach_function :deflateReset, [:pointer], :int
+    attach_function :deflateParams, [:pointer, :int, :int], :int
+    attach_function :deflateTune, [:pointer, :int, :int, :int, :int], :int
+    attach_function :deflateBound, [:pointer, :ulong], :ulong
+    attach_function :deflatePrime, [:pointer, :int, :int], :int
+    attach_function :deflateSetHeader, [:pointer, :pointer], :int
+
+    # -------------------------------------------------------------------------
+
+    def self.inflateInit(zstream)
+        inflateInit_(zstream, ZLIB_VERSION, zstream.size)
+    end
+
+    def self.inflateInit2(zstream, window_bits)
+        inflateInit2_(zstream, window_bits, ZLIB_VERSION, zstream.size)
+    end
+
+    attach_function :inflateInit_, [:pointer, :string, :int], :int
+    attach_function :inflateInit2_, [:pointer, :int, :string, :int], :int
+    attach_function :inflate, [:pointer, :int], :int
+    attach_function :inflateEnd, [:pointer], :int
+    
+    attach_function :inflateSetDictionary, [:pointer, :pointer, :uint], :int
+    attach_function :inflateSync, [:pointer], :int
+    attach_function :inflateCopy, [:pointer, :pointer], :int
+    attach_function :inflateReset, [:pointer], :int
+    attach_function :inflatePrime, [:pointer, :int, :int], :int
+    attach_function :inflateGetHeader, [:pointer, :pointer], :int
+
+    callback :in_func, [:pointer, :pointer], :uint
+    callback :out_func, [:pointer, :pointer, :uint], :int
+
+    attach_function :inflateBackInit_, [:pointer, :int, :pointer], :int
+    attach_function :inflateBack, [:pointer, :in_func, :pointer, :out_func, :pointer], :int
+    attach_function :inflateBackEnd, [:pointer], :int
+
+    # -------------------------------------------------------------------------
+
+    attach_function :compress, [:pointer, :buffer_inout, :pointer, :ulong], :int
+    attach_function :compress2, [:pointer, :pointer, :pointer, :ulong, :int], :int
+    attach_function :compressBound, [:ulong], :ulong
+
+    attach_function :uncompress, [:pointer, :buffer_inout, :pointer, :ulong], :int
+
+    # -------------------------------------------------------------------------
+
+    attach_function :gzopen, [:string, :string], :pointer
+    attach_function :gzdopen, [:int, :string], :pointer
+    attach_function :gzsetparams, [:pointer, :int, :int], :int
+    attach_function :gzread, [:pointer, :pointer, :uint], :int
+    attach_function :gzwrite, [:pointer, :pointer, :uint], :int
+    attach_function :gzprintf, [:pointer, :string, :varargs], :int
+    attach_function :gzputs, [:pointer, :string], :int
+    attach_function :gzgets, [:pointer, :pointer, :int], :pointer
+    attach_function :gzputc, [:pointer, :int], :int
+    attach_function :gzgetc, [:pointer, :pointer], :int
+    attach_function :gzungetc, [:int, :pointer], :int
+    attach_function :gzflush, [:pointer, :int], :int
+    attach_function :gzseek, [:pointer, :long, :int], :long
+    attach_function :gzrewind, [:pointer], :int
+    attach_function :gztell, [:pointer], :long
+    attach_function :gzeof, [:pointer], :int
+    attach_function :gzdirect, [:pointer], :int
+    attach_function :gzclose, [:pointer], :int
+    attach_function :gzerror, [:pointer, :buffer_out], :string
+    attach_function :gzclearerr, [:pointer], :void
+
+    # -------------------------------------------------------------------------
+
+    attach_function :adler32, [:ulong, :pointer, :uint], :ulong
+    attach_function :adler32_combine, [:ulong, :ulong, :long], :ulong
+    attach_function :crc32, [:ulong, :pointer, :uint], :ulong
+    attach_function :crc32_combine, [:ulong, :ulong, :long], :ulong
+
+    # -------------------------------------------------------------------------
+        
+    attach_function :zlibCompileFlags, [ ], :ulong
+    attach_function :zError, [:int], :string
+    attach_function :inflateSyncPoint, [:pointer], :int
+    attach_function :get_crc_table, [ ], :pointer
+
+    # -------------------------------------------------------------------------
+end
+
+# =============================================================================

data/test/fixtures/pale_blue_dot.txt

@@ -0,0 +1,35 @@
+Look again at that dot. That's here. That's home. That's us. On it everyone you
+love, everyone you know, everyone you ever heard of, every human being who ever
+was, lived out their lives. The aggregate of our joy and suffering, thousands of
+confident religions, ideologies, and economic doctrines, every hunter and
+forager, every hero and coward, every creator and destroyer of civilization,
+every king and peasant, every young couple in love, every mother and father,
+hopeful child, inventor and explorer, every teacher of morals, every corrupt
+politician, every "superstar," every "supreme leader," every saint and sinner in
+the history of our species lived there – on a mote of dust suspended in a
+sunbeam.
+
+The Earth is a very small stage in a vast cosmic arena. Think of the rivers of
+blood spilled by all those generals and emperors so that, in glory and triumph,
+they could become the momentary masters of a fraction of a dot. Think of the
+endless cruelties visited by the inhabitants of one corner of this pixel on the
+scarcely distinguishable inhabitants of some other corner, how frequent their
+misunderstandings, how eager they are to kill one another, how fervent their
+hatreds.
+
+Our posturings, our imagined self-importance, the delusion that we have some
+privileged position in the Universe, are challenged by this point of pale light.
+Our planet is a lonely speck in the great enveloping cosmic dark. In our
+obscurity, in all this vastness, there is no hint that help will come from
+elsewhere to save us from ourselves.
+
+The Earth is the only world known so far to harbor life. There is nowhere else,
+at least in the near future, to which our species could migrate. Visit, yes.
+Settle, not yet. Like it or not, for the moment the Earth is where we make our
+stand.
+
+It has been said that astronomy is a humbling and character-building experience.
+There is perhaps no better demonstration of the folly of human conceits than
+this distant image of our tiny world. To me, it underscores our responsibility
+to deal more kindly with one another, and to preserve and cherish the pale blue
+dot, the only home we've ever known.

data/test/test_checksums.rb

@@ -0,0 +1,92 @@
+require "test/unit"
+require "ffi/zlib"
+require "test/helper.rb"
+
+class TestAdler32 < Test::Unit::TestCase
+    include Setup
+
+    EXPECTED_ADLER32_1    = 3874980441
+    EXPECTED_ADLER32_2    = 1707704336
+    EXPECTED_ADLER32_FULL = 869204599
+    
+    def adler32(data)
+        @buffer.put_string(0, data)
+        checksum = FFI::Zlib.adler32(0, nil, 0)
+        FFI::Zlib.adler32(checksum, @buffer, data.length)
+    end
+    
+    def test_adler32
+        checksum = self.adler32(@data)
+        assert_equal checksum, EXPECTED_ADLER32_FULL
+    end
+
+    def test_running_adler32
+        checksum = FFI::Zlib.adler32(0, nil, 0)
+        @data.each_line do |line|
+            @buffer.put_string(0, line)
+            checksum = FFI::Zlib.adler32(checksum, @buffer, line.length)
+        end
+
+        assert_equal checksum, EXPECTED_ADLER32_FULL
+    end
+
+    def test_adler32_combine
+        middle, _ = @data.length.divmod(2)
+        piece1 = @data[0...middle]
+        piece2 = @data[middle..-1]
+
+        checksum1 = self.adler32(piece1)
+        checksum2 = self.adler32(piece2)
+        checksum = FFI::Zlib.adler32_combine(checksum1, checksum2, piece2.length)
+
+        assert_equal checksum1, EXPECTED_ADLER32_1
+        assert_equal checksum2, EXPECTED_ADLER32_2
+        assert_equal checksum,  EXPECTED_ADLER32_FULL
+    end
+    
+    
+end
+
+class TestCRC32 < Test::Unit::TestCase
+    include Setup
+
+    EXPECTED_CRC32_1      = 4007132158
+    EXPECTED_CRC32_2      = 1117097248
+    EXPECTED_CRC32_FULL   = 703194008
+
+    def crc32(data)
+        @buffer.put_string(0, data)
+        checksum = FFI::Zlib.crc32(0, nil, 0)
+        checksum = FFI::Zlib.crc32(checksum, @buffer, data.length)
+    end
+    
+    def test_crc32
+        checksum = self.crc32(@data)
+        assert_equal checksum, EXPECTED_CRC32_FULL
+    end
+
+    def test_running_crc32
+        checksum = FFI::Zlib.crc32(0, nil, 0)
+        @data.each_line do |line|
+            @buffer.put_string(0, line)
+            checksum = FFI::Zlib.crc32(checksum, @buffer, line.length)
+        end
+
+        assert_equal checksum, EXPECTED_CRC32_FULL
+    end
+
+    def test_crc32_combine
+        middle, _ = @data.length.divmod(2)
+        piece1 = @data[0...middle]
+        piece2 = @data[middle..-1]
+
+        checksum1 = self.crc32(piece1)
+        checksum2 = self.crc32(piece2)
+        checksum = FFI::Zlib.crc32_combine(checksum1, checksum2, piece2.length)
+
+        assert_equal checksum1, EXPECTED_CRC32_1
+        assert_equal checksum2, EXPECTED_CRC32_2
+        assert_equal checksum,  EXPECTED_CRC32_FULL
+    end
+
+end

data/test/test_compress.rb

@@ -0,0 +1,52 @@
+require "test/unit"
+require "ffi/zlib"
+require "test/helper.rb"
+
+class TestCompress < Test::Unit::TestCase
+    include Setup
+    
+    def test_compress
+        do_test
+
+        s1 = do_test(FFI::Zlib::Z_NO_COMPRESSION)
+        s2 = do_test(FFI::Zlib::Z_BEST_SPEED)
+        s3 = do_test(FFI::Zlib::Z_DEFAULT_COMPRESSION)
+        s4 = do_test(FFI::Zlib::Z_BEST_COMPRESSION)
+        
+        assert s1 > s2
+        assert s2 > s3
+        assert s3 >= s4
+    end
+    
+    def do_test(level=nil)
+        @buffer.put_string(0, @data)
+
+        buffer_size = FFI::Zlib.compressBound(@data.length)
+        assert_not_equal buffer_size, 0
+
+        compressed_buffer_size = FFI::Buffer.alloc_inout(:ulong).put_ulong(0, buffer_size)
+        compressed_buffer = FFI::MemoryPointer.new(buffer_size)
+        
+        if level.nil?
+            result = FFI::Zlib.compress(compressed_buffer, compressed_buffer_size, @buffer, @data.length)
+        else
+            result = FFI::Zlib.compress2(compressed_buffer, compressed_buffer_size, @buffer, @data.length, level)
+        end
+
+        compressed_size = compressed_buffer_size.get_ulong(0)
+        assert_equal result, FFI::Zlib::Z_OK
+        
+        uncompressed_buffer_size = FFI::Buffer.alloc_inout(:ulong).put_ulong(0, @data.length)
+        uncompressed_buffer = FFI::MemoryPointer.new(@data.length)
+        result = FFI::Zlib.uncompress(uncompressed_buffer, uncompressed_buffer_size, compressed_buffer, compressed_size)
+
+        uncompressed_size = uncompressed_buffer_size.get_ulong(0)
+        uncompressed = uncompressed_buffer.get_string(0)
+        assert_equal result, FFI::Zlib::Z_OK
+        assert_equal uncompressed_size, @data.length
+        assert_equal uncompressed, @data
+        
+        return compressed_size
+    end
+
+end

data/test/test_deflate.rb

@@ -0,0 +1,71 @@
+require "test/unit"
+require "ffi/zlib"
+require "test/helper.rb"
+
+class TestDeflate < Test::Unit::TestCase
+
+    def setup
+        @data = File.read(File.join("test", "fixtures", "pale_blue_dot.txt"))
+        @buffer = FFI::MemoryPointer.new(@data.length)
+        @buffer.put_string(0, @data)
+    end
+    
+    def test_deflate
+        s1 = do_test_deflate(FFI::Zlib::Z_NO_COMPRESSION)
+        s2 = do_test_deflate(FFI::Zlib::Z_BEST_SPEED)
+        s3 = do_test_deflate(FFI::Zlib::Z_DEFAULT_COMPRESSION)
+        s4 = do_test_deflate(FFI::Zlib::Z_BEST_COMPRESSION)
+
+        assert s1 > s2
+        assert s2 > s3
+        assert s3 >= s4
+    end
+    
+    def do_test_deflate(level)
+        avail_out = @data.length + 64
+        compressed_buffer = FFI::MemoryPointer.new(avail_out)
+
+        zstream = FFI::Zlib::Z_stream.new
+        zstream[:next_in] = @buffer
+        zstream[:avail_in] = @data.length
+        zstream[:next_out] = compressed_buffer
+        zstream[:avail_out] = avail_out
+
+        result = FFI::Zlib.deflateInit(zstream, level)
+        assert_equal result, FFI::Zlib::Z_OK
+
+        result = FFI::Zlib.deflate(zstream, FFI::Zlib::Z_FINISH)
+        assert_equal result, FFI::Zlib::Z_STREAM_END
+
+        result = FFI::Zlib.deflateEnd(zstream)
+        assert_equal result, FFI::Zlib::Z_OK
+        
+        compressed_size = zstream[:total_out]
+        assert compressed_size > 0
+        assert compressed_size <= @data.length if level != FFI::Zlib::Z_NO_COMPRESSION
+
+        decompressed_buffer = FFI::MemoryPointer.new(@data.length)
+        zstream = FFI::Zlib::Z_stream.new
+        zstream[:next_in] = compressed_buffer
+        zstream[:avail_in] = compressed_size
+        zstream[:next_out] = decompressed_buffer
+        zstream[:avail_out] = @data.length
+
+        result = FFI::Zlib.inflateInit(zstream)
+        assert_equal result, FFI::Zlib::Z_OK
+
+        result = FFI::Zlib.inflate(zstream, FFI::Zlib::Z_FINISH)
+        assert_equal result, FFI::Zlib::Z_STREAM_END
+
+        result = FFI::Zlib.inflateEnd(zstream)
+        assert_equal result, FFI::Zlib::Z_OK
+
+        decompressed_size = zstream[:total_out]
+        decompressed_data = decompressed_buffer.get_string(0, decompressed_size)
+        assert_equal decompressed_size, @data.length
+        assert_equal decompressed_data, @data
+
+        return compressed_size
+    end
+
+end

data/test/test_gz.rb

@@ -0,0 +1,3 @@
+require "test/unit"
+require "ffi/zlib"
+require "test/helper.rb"

data/test/test_misc.rb

@@ -0,0 +1,38 @@
+require "test/unit"
+require "ffi/zlib"
+require "test/helper.rb"
+
+class TestMisc < Test::Unit::TestCase
+    
+    def test_version
+        assert_not_nil FFI::Zlib.zlibVersion
+    end
+    
+    def test_compile_flags
+        assert_not_equal FFI::Zlib.zlibCompileFlags, 0
+    end
+    
+    def test_crc_table
+        table = FFI::Zlib.get_crc_table
+        assert_not_nil table
+    end
+    
+    def test_errors
+        do_test_error FFI::Zlib::Z_OK
+        do_test_error FFI::Zlib::Z_STREAM_END
+        do_test_error FFI::Zlib::Z_NEED_DICT
+        do_test_error FFI::Zlib::Z_ERRNO
+        do_test_error FFI::Zlib::Z_STREAM_ERROR
+        do_test_error FFI::Zlib::Z_DATA_ERROR
+        do_test_error FFI::Zlib::Z_MEM_ERROR
+        do_test_error FFI::Zlib::Z_BUF_ERROR
+        do_test_error FFI::Zlib::Z_VERSION_ERROR
+    end
+    
+    def do_test_error(err)
+        err_str = FFI::Zlib.zError(err)
+        assert_not_nil err_str
+        assert_instance_of String, err_str
+    end
+    
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: ffi-zlib
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- Luc Heinrich
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-31 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ffi
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: ffi-zlib provides a very thin wrapper around zlib using the Ruby FFI library.
+email: luc@honk-honk.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/ffi/zlib.rb
+- test/fixtures/pale_blue_dot.txt
+- README.md
+- LICENSE
+- test/test_checksums.rb
+- test/test_compress.rb
+- test/test_deflate.rb
+- test/test_gz.rb
+- test/test_misc.rb
+has_rdoc: true
+homepage: http://github.com/lucsky/ffi-zlib
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: FFI based wrapper for zlib.
+test_files: 
+- test/test_checksums.rb
+- test/test_compress.rb
+- test/test_deflate.rb
+- test/test_gz.rb
+- test/test_misc.rb