pr-zlib 1.0.0

data/CHANGES

@@ -0,0 +1,2 @@
+= 1.0.0 - 12-Jun-2009
+* Initial release

data/MANIFEST

@@ -0,0 +1,18 @@
+CHANGES
+MANIFEST
+README
+pr-zlib.gemspec
+bin/minizip.rb
+examples/example_rbzlib.rb
+lib/pr/rbzlib.rb
+lib/pr/zlib.rb
+test/test_rbzlib_bytef.rb
+test/test_rbzlib_posf.rb
+test/test_rbzlib.rb
+test/test_zlib_deflate.rb
+test/test_zlib_gzip_file.rb
+test/test_zlib_gzip_reader.rb
+test/test_zlib_gzip_writer.rb
+test/test_zlib_inflate.rb
+test/test_zlib_zstream.rb
+test/test_zlib.rb

data/README

@@ -0,0 +1,42 @@
+= Description
+The pr-zlib library is a pure Ruby version of the zlib compression library.
+It consists of both a port of zlib.h and the Ruby zlib library that ships as
+part of the standard library.
+
+= Synopsis
+
+# Imitating a bit of code used in rubygems
+require 'pr/zlib'
+require 'stringio'
+
+data = StringIO.new(data)
+Zlib::GzipReader.new(data).read
+
+= Motivation
+
+First, building the zlib C library on MS Windows with Visual C++ is very
+difficult. However, certain libraries depend on zlib, most notably rubygems.
+By providing a pure Ruby version we eliminate any compiler or platform
+compatability issues.
+
+Second, even some Unix distributions, such as Debian, do not ship with
+the zlib library by default. By creating a pure Ruby version of the zlib
+library we eliminate the need to install a 3rd party C library, and
+eliminate a potential weak link in the dependency chain.
+
+Third, by creating pure Ruby versions of the library and the interface we
+are more likely to receive patches, feature requests, documentation updates,
+etc, from the Ruby community since not everyone who knows Ruby also knows C.
+
+Last, the zlib interface that ships as part of the stdlib is a little on the
+clunky side. By providing a pure Ruby version, authors can create their own
+interface as they see fit.
+
+= TODO
+
+More tests, and better tests, are needed for both Rbzlib and Zlib.
+
+= Authors
+
+* Park Heesob (C translation)
+* Daniel Berger (Testing, packaging, deployment)

data/Rakefile

@@ -0,0 +1,88 @@
+require 'rake'
+require 'rake/testtask'
+require 'rbconfig'
+
+desc 'Install the pr-zlib library'
+task :install do
+   install_dir = File.join(Config::CONFIG['sitelibdir'], 'pr')
+   Dir.mkdir(install_dir) unless File.exists?(install_dir)
+   files = ['lib/pr/zlib.rb', 'lib/pr/rbzlib.rb']
+   files.each{ |file|
+      FileUtils.cp(file, install_dir, :verbose => true)
+   }
+end
+
+desc 'Install the pr-zlib library as zlib'
+task :install_as_zlib do
+   install_dir = File.join(Config::CONFIG['sitelibdir'], 'pr')
+   Dir.mkdir(install_dir) unless File.exists?(install_dir)
+
+   FileUtils.cp('lib/pr/zlib.rb', Config::CONFIG['sitelibdir'], :verbose => true)
+   FileUtils.cp('lib/pr/rbzlib.rb', install_dir, :verbose => true)
+end
+
+desc 'Install the pr-zlib library as a gem'
+task :install_gem do
+   ruby 'pr-zlib.gemspec'
+   file = Dir["*.gem"].first
+   sh "gem install #{file}"
+end
+
+Rake::TestTask.new do |t|
+   t.warning = true
+   t.verbose = true   
+end
+
+Rake::TestTask.new('test_zlib') do |t|
+   t.warning = true
+   t.verbose = true
+   t.test_files = FileList['test/test_zlib.rb']
+end
+
+Rake::TestTask.new('test_gzip_file') do |t|
+   t.warning = true
+   t.verbose = true
+   t.test_files = FileList['test/test_zlib_gzip_file.rb']
+end
+
+Rake::TestTask.new('test_gzip_reader') do |t|
+   t.warning = true
+   t.verbose = true
+   t.test_files = FileList['test/test_zlib_gzip_reader.rb']
+end
+
+Rake::TestTask.new('test_gzip_writer') do |t|
+   t.warning = true
+   t.verbose = true
+   t.test_files = FileList['test/test_zlib_gzip_writer.rb']
+end
+
+Rake::TestTask.new('test_deflate') do |t|
+   t.warning = true
+   t.verbose = true
+   t.test_files = FileList['test/test_zlib_deflate.rb']
+end
+
+Rake::TestTask.new('test_inflate') do |t|
+   t.warning = true
+   t.verbose = true
+   t.test_files = FileList['test/test_zlib_inflate.rb']
+end
+
+Rake::TestTask.new('test_rbzlib') do |t|
+   t.warning = true
+   t.verbose = true
+   t.test_files = FileList['test/test_rbzlib.rb']
+end
+
+Rake::TestTask.new('test_rbzlib_bytef') do |t|
+   t.warning = true
+   t.verbose = true
+   t.test_files = FileList['test/test_rbzlib_bytef.rb']
+end
+
+Rake::TestTask.new('test_rbzlib_posf') do |t|
+   t.warning = true
+   t.verbose = true
+   t.test_files = FileList['test/test_rbzlib_posf.rb']
+end

data/bin/minizip.rb

@@ -0,0 +1,173 @@
+# minigzip.rb -- simulate gzip using the zlib compression library
+# Copyright (C) 1995-2005 Jean-loup Gailly.
+# For conditions of distribution and use, see copyright notice in rbzlib.rb
+#
+#
+#
+# minigzip is a minimal implementation of the gzip utility. This is
+# only an example of using zlib and isn't meant to replace the
+# full-featured gzip. No attempt is made to deal with file systems
+# limiting names to 14 or 8+3 characters, etc... Error checking is
+# very limited. So use minigzip only for testing; use gzip for the
+# real thing. On MSDOS, use only on file names without extension
+# or in pipe mode.
+#              
+# Ruby tralnslation By Park Heesob.
+
+require 'rbzlib'
+include Rbzlib
+
+GZ_SUFFIX = ".gz"
+SUFFIX_LEN = GZ_SUFFIX.length
+
+BUFLEN      = 16384
+MAX_NAME_LEN = 1024
+
+
+def error(msg)
+    puts("#{__FILE__}: #{msg}")
+    exit(1)
+end
+
+def gz_compress(_in, out)
+    while(true)
+      begin
+        buf = _in.read(BUFLEN)
+      rescue 
+        raise RuntimeError,"read"
+      end
+      break if buf.nil?
+      err = 0
+      len = buf.length
+      if (gzwrite(out, buf, len) != len)
+        error(gzerror(out, err))
+      end
+    end
+    _in.close
+    error("failed gzclose") if (gzclose(out) != Z_OK) 
+end
+
+
+def gz_uncompress(_in, out)
+    buf = 0.chr * BUFLEN
+    while true
+        len = gzread(_in, buf, buf.length)
+        err = 0
+        error(gzerror(_in, err)) if (len < 0) 
+        break if len.zero?
+		if(out.write(buf[0,len]) != len)
+            error("failed write")
+        end
+    end
+    begin
+      out.close
+    rescue
+      error("failed fclose") 
+    end
+
+    error("failed gzclose") if (gzclose(_in) != Z_OK) 
+end
+
+
+def file_compress(file, mode)
+    outfile = file + GZ_SUFFIX
+
+    _in = File.open(file, "rb")
+    if _in.nil? 
+        raise RuntimeError,file
+    end
+    out = gzopen(outfile, mode)
+    if out.nil?
+        puts("#{__FILE__}: can't gzopen #{outfile}")
+        exit(1)
+    end
+    gz_compress(_in, out)
+
+    File.unlink(file)
+end
+
+
+def file_uncompress(file)
+    len = file.length
+    buf = file.dup
+
+    if (file[-SUFFIX_LEN..-1] == GZ_SUFFIX)
+        infile = file.dup
+        outfile = buf[0..(-SUFFIX_LEN-1)]
+    else 
+        outfile = file.dup
+        infile = buf + GZ_SUFFIX
+    end
+    _in = gzopen(infile, "rb")
+    if _in.nil? 
+        puts("#{__FILE__}: can't gzopen #{infile}")
+        exit(1)
+    end
+    out = File.open(outfile, "wb")
+    if out.nil? 
+        raise RuntimeError,file
+        exit(1)
+    end
+
+    gz_uncompress(_in, out)
+
+    File.unlink(infile)
+end
+
+
+#===========================================================================
+# Usage:  minigzip [-d] [-f] [-h] [-r] [-1 to -9] [files...]
+#  -d : decompress
+#  -f : compress with Z_FILTERED
+#  -h : compress with Z_HUFFMAN_ONLY
+#  -r : compress with Z_RLE
+#  -1 to -9 : compression level
+#
+
+    uncompr = false
+
+    outmode = "wb6 "
+
+    while !ARGV.empty?
+      argv = ARGV.shift
+      case argv
+      when "-d"
+        uncompr = true
+      when "-f"
+        outmode[3] = 'f'
+      when "-h"
+        outmode[3] = 'h'
+      when "-r"
+        outmode[3] = 'R'
+      when "-1".."-9"
+        outmode[2] = argv[1]
+      else
+        ARGV.unshift(argv)
+        break
+      end
+    end
+    if (outmode[3].chr == ' ')
+        outmode = outmode[0,3]
+    end
+    if (ARGV.empty?)        
+        $stdin.binmode
+        $stdout.binmode
+        if (uncompr) 
+            file = gzdopen($stdin.fileno, "rb")
+            error("can't gzdopen stdin") if file.nil? 
+            gz_uncompress(file, $stdout)
+        else 
+            file = gzdopen($stdout.fileno, outmode)
+            error("can't gzdopen stdout") if file.nil? 
+            gz_compress($stdin, file)
+        end
+    else 
+        while !ARGV.empty? 
+            if (uncompr) 
+                file_uncompress(ARGV.shift)
+            else 
+                file_compress(ARGV.shift, outmode)
+            end
+        end
+    end
+

data/examples/example_rbzlib.rb

@@ -0,0 +1,385 @@
+# example.rb -- usage example of the zlib compression library
+# Copyright (C) 1995-2004 Jean-loup Gailly.
+# For conditions of distribution and use, see copyright notice in rbzlib.rb
+#
+# Ruby translation by Park Heesob
+
+require 'rbzlib'
+include Rbzlib
+
+def CHECK_ERR(err,msg)
+  if(err != Z_OK)
+    raise RuntimeError,"#{msg} error: #{err}"
+  end
+end
+
+TESTFILE = "foo.gz"
+@@hello = "hello, hello!\0"
+
+@@dictionary = "hello"
+
+def test_compress(compr, comprLen, uncompr, uncomprLen)
+    len = @@hello.length
+
+    err,comprLen = compress(compr, comprLen, @@hello, len)
+    CHECK_ERR(err, "compress")
+    compr = compr[0,comprLen]
+    uncompr[0,7] = "garbage"
+    err,uncomprLen = uncompress(uncompr, uncomprLen, compr, comprLen)
+    CHECK_ERR(err, "uncompress")
+    uncompr = uncompr[0,uncomprLen]
+    if uncompr != @@hello
+        puts("bad uncompress")
+        exit(1)
+    else
+        puts("uncompress(): #{uncompr}")
+    end
+end
+
+def test_gzio(fname, uncompr, uncomprLen)
+    len = @@hello.length
+    err = 0
+    file = gzopen(fname, "wb")
+    if file.nil?
+        puts("gzopen error")
+        exit(1)
+    end
+    gzputc(file, 'h')
+    if (gzputs(file, "ello") != 4)
+        puts("gzputs err: #{gzerror(file, err)}")
+        exit(1)
+    end
+    if (gzputs(file, ", hello!") != 8)
+        puts("gzputs err: #{gzerror(file, err)}")
+        exit(1)
+    end
+    gzseek(file, 1, SEEK_CUR)
+    gzclose(file)
+
+    file = gzopen(fname, "rb")
+    if file.nil?
+        puts("gzopen error")
+        exit(1)
+    end
+    uncompr[0,7] = "garbage"
+    if (gzread(file, uncompr, uncomprLen) != len)
+        puts("gzread err: #{gzerror(file, err)}")
+        exit(1)
+    end
+    uncompr = uncompr[0,len]
+    if uncompr != @@hello
+        puts("bad gzread: #{uncompr}")
+        exit(1)
+    else
+        puts("gzread(): #{uncompr}")
+    end
+    pos = gzseek(file, -8, SEEK_CUR)
+    if (pos != 6 || gztell(file) != pos)
+        puts("gzseek error, pos=#{pos}, gztell=#{gztell(file)}")
+        exit(1)
+    end
+
+    if (gzgetc(file) != ' ')
+        puts("gzgetc error")
+        exit(1)
+    end
+
+    if (gzungetc(' ', file) != ' ')
+        puts("gzungetc error")
+        exit(1)
+    end
+
+    gzgets(file, uncompr, uncomprLen)
+    uncompr.chop!
+    if uncompr.length != 7
+        puts("gzgets err after gzseek: #{gzerror(file, err)}")
+        exit(1)
+    end
+
+    if uncompr != @@hello[6..-2]
+        puts("bad gzgets after gzseek")
+        exit(1)
+    else
+        puts("gzgets() after gzseek: #{uncompr}")
+    end
+
+    gzclose(file)
+end
+
+def test_deflate(compr, comprLen)
+    c_stream = Z_stream.new
+    len = @@hello.length
+
+    err = deflateInit(c_stream, Z_DEFAULT_COMPRESSION)
+    CHECK_ERR(err, "deflateInit")
+
+    c_stream.next_in  = Bytef.new(@@hello)
+    c_stream.next_out = Bytef.new(compr)
+
+    while (c_stream.total_in != len && c_stream.total_out < comprLen)
+        c_stream.avail_in = c_stream.avail_out = 1
+        err = deflate(c_stream, Z_NO_FLUSH)
+        CHECK_ERR(err, "deflate")
+    end
+    while true
+        c_stream.avail_out = 1
+        err = deflate(c_stream, Z_FINISH)
+        break if (err == Z_STREAM_END)
+        CHECK_ERR(err, "deflate")
+    end
+
+    err = deflateEnd(c_stream)
+    CHECK_ERR(err, "deflateEnd")
+end
+
+def test_inflate(compr, comprLen, uncompr, uncomprLen)
+    uncompr[0,7] = "garbage"
+    d_stream = Z_stream.new
+
+    d_stream.next_in  = Bytef.new(compr)
+    d_stream.avail_in = 0
+    d_stream.next_out = Bytef.new(uncompr)
+
+    err = inflateInit(d_stream)
+    CHECK_ERR(err, "inflateInit")
+
+    while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen)
+        d_stream.avail_in = d_stream.avail_out = 1
+        err = inflate(d_stream, Z_NO_FLUSH)
+        break if (err == Z_STREAM_END)
+        CHECK_ERR(err, "inflate")
+    end
+
+    err = inflateEnd(d_stream)
+    CHECK_ERR(err, "inflateEnd")
+    uncompr = uncompr[0,d_stream.total_out]
+    if uncompr != @@hello
+        puts("bad inflate")
+        exit(1)
+    else
+        puts("inflate(): #{uncompr}")
+    end
+end
+
+def test_large_deflate(compr, comprLen, uncompr, uncomprLen)
+    c_stream = Z_stream.new
+    err = deflateInit(c_stream, Z_BEST_SPEED)
+    CHECK_ERR(err, "deflateInit")
+
+    c_stream.next_out = Bytef.new(compr)
+    c_stream.avail_out = comprLen
+    c_stream.next_in = Bytef.new(uncompr)
+    c_stream.avail_in = uncomprLen
+    err = deflate(c_stream, Z_NO_FLUSH)
+    CHECK_ERR(err, "deflate")
+    if c_stream.avail_in.nonzero?
+        puts("deflate not greedy")
+        exit(1)
+    end
+
+    deflateParams(c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY)
+    c_stream.next_in = Bytef.new(compr)
+    c_stream.avail_in = comprLen/2
+    err = deflate(c_stream, Z_NO_FLUSH)
+    CHECK_ERR(err, "deflate")
+
+    deflateParams(c_stream, Z_BEST_COMPRESSION, Z_FILTERED)
+    c_stream.next_in = Bytef.new(uncompr)
+    c_stream.avail_in = uncomprLen
+    err = deflate(c_stream, Z_NO_FLUSH)
+    CHECK_ERR(err, "deflate")
+
+    err = deflate(c_stream, Z_FINISH)
+    if (err != Z_STREAM_END)
+        puts("deflate should report Z_STREAM_END")
+        exit(1)
+    end
+    err = deflateEnd(c_stream)
+    CHECK_ERR(err, "deflateEnd")
+end
+
+def test_large_inflate(compr, comprLen, uncompr, uncomprLen)
+    d_stream = Z_stream.new
+    uncompr[0,7] = "garbage"
+
+    d_stream.next_in  = Bytef.new(compr)
+    d_stream.avail_in = comprLen
+
+    err = inflateInit(d_stream)
+    CHECK_ERR(err, "inflateInit")
+
+    while true
+        d_stream.next_out = Bytef.new(uncompr)
+        d_stream.avail_out = uncomprLen
+        err = inflate(d_stream, Z_NO_FLUSH)
+        break if (err == Z_STREAM_END)
+        CHECK_ERR(err, "large inflate")
+    end
+
+    err = inflateEnd(d_stream)
+    CHECK_ERR(err, "inflateEnd")
+
+    if (d_stream.total_out != 2*uncomprLen + comprLen/2)
+        puts("bad large inflate: #{d_stream.total_out}")
+        exit(1)
+    else
+        puts("large_inflate(): OK")
+    end
+end
+
+def test_flush(compr, comprLen)
+    c_stream = Z_stream.new
+    len = @@hello.length
+
+    err = deflateInit(c_stream, Z_DEFAULT_COMPRESSION)
+    CHECK_ERR(err, "deflateInit")
+
+    c_stream.next_in  = Bytef.new(@@hello)
+    c_stream.next_out = Bytef.new(compr)
+    c_stream.avail_in = 3
+    c_stream.avail_out = comprLen
+    err = deflate(c_stream, Z_FULL_FLUSH)
+    CHECK_ERR(err, "deflate")
+
+    compr[3]=(compr[3].ord+1).chr
+    c_stream.avail_in = len - 3
+
+    err = deflate(c_stream, Z_FINISH)
+    if (err != Z_STREAM_END)
+        CHECK_ERR(err, "deflate")
+    end
+    err = deflateEnd(c_stream)
+    CHECK_ERR(err, "deflateEnd")
+
+    comprLen = c_stream.total_out
+end
+
+def test_sync(compr, comprLen, uncompr, uncomprLen)
+    d_stream = Z_stream.new
+    uncompr[0,7] = "garbage"
+
+    d_stream.next_in  = Bytef.new(compr)
+    d_stream.avail_in = 2
+
+    err = inflateInit(d_stream)
+    CHECK_ERR(err, "inflateInit")
+
+    d_stream.next_out = Bytef.new(uncompr)
+    d_stream.avail_out = uncomprLen
+
+    inflate(d_stream, Z_NO_FLUSH)
+    CHECK_ERR(err, "inflate")
+
+    d_stream.avail_in = comprLen-2
+    err = inflateSync(d_stream)
+    CHECK_ERR(err, "inflateSync")
+
+    err = inflate(d_stream, Z_FINISH)
+    if (err != Z_DATA_ERROR)
+        puts("inflate should report DATA_ERROR")
+        exit(1)
+    end
+    err = inflateEnd(d_stream)
+    uncompr = uncompr[0,d_stream.total_out]
+    CHECK_ERR(err, "inflateEnd")
+    puts("after inflateSync(): hel#{uncompr}")
+end
+
+def test_dict_deflate(compr, comprLen)
+    c_stream = Z_stream.new
+    err = deflateInit(c_stream, Z_BEST_COMPRESSION)
+    CHECK_ERR(err, "deflateInit")
+
+    err = deflateSetDictionary(c_stream,@@dictionary, @@dictionary.length)
+    CHECK_ERR(err, "deflateSetDictionary")
+
+    @@dictId = c_stream.adler
+    c_stream.next_out = Bytef.new(compr)
+    c_stream.avail_out = comprLen
+
+    c_stream.next_in = Bytef.new(@@hello)
+    c_stream.avail_in = @@hello.length
+
+    err = deflate(c_stream, Z_FINISH)
+    if (err != Z_STREAM_END)
+        puts("deflate should report Z_STREAM_END")
+        exit(1)
+    end
+    err = deflateEnd(c_stream)
+    CHECK_ERR(err, "deflateEnd")
+end
+
+def test_dict_inflate(compr, comprLen, uncompr, uncomprLen)
+    d_stream = Z_stream.new
+    uncompr[0,7] = "garbage"
+
+    d_stream.next_in  = Bytef.new(compr)
+    d_stream.avail_in = comprLen
+
+    err = inflateInit(d_stream)
+    CHECK_ERR(err, "inflateInit")
+    d_stream.next_out = Bytef.new(uncompr)
+    d_stream.avail_out = uncomprLen
+
+    while true
+        err = inflate(d_stream, Z_NO_FLUSH)
+        break if (err == Z_STREAM_END)
+        if (err == Z_NEED_DICT)
+            if (d_stream.adler != @@dictId)
+                puts("unexpected dictionary")
+                exit(1)
+            end
+            err = inflateSetDictionary(d_stream, @@dictionary,@@dictionary.length)
+
+        end
+        CHECK_ERR(err, "inflate with dict")
+    end
+
+    err = inflateEnd(d_stream)
+    CHECK_ERR(err, "inflateEnd")
+    uncompr = uncompr[0,d_stream.total_out]
+    if uncompr != @@hello
+        puts("bad inflate with dict")
+        exit(1)
+    else
+        puts("inflate with dictionary: #{uncompr}")
+    end
+end
+
+    comprLen = 10000*4
+    uncomprLen = comprLen
+    myVersion = ZLIB_VERSION
+
+    if (zlibVersion[0] != myVersion[0])
+        puts("incompatible zlib version")
+        exit(1)
+    elsif (zlibVersion != ZLIB_VERSION)
+        puts("warning: different zlib version")
+    end
+
+    compr    = 0.chr * comprLen
+    uncompr  = 0.chr * uncomprLen
+    if (compr.nil? || uncompr.nil?)
+        puts("out of memory")
+        exit(1)
+    end
+    test_compress(compr, comprLen, uncompr, uncomprLen)
+
+    test_gzio((ARGV.length > 0 ? ARGV[0] : TESTFILE),
+              uncompr, uncomprLen)
+
+    test_deflate(compr, comprLen)
+    test_inflate(compr, comprLen, uncompr, uncomprLen)
+    test_large_deflate(compr, comprLen, uncompr, uncomprLen)
+    test_large_inflate(compr, comprLen, uncompr, uncomprLen)
+
+    test_flush(compr, comprLen)
+
+    test_sync(compr, comprLen, uncompr, uncomprLen)
+    comprLen = uncomprLen
+
+    test_dict_deflate(compr, comprLen)
+    test_dict_inflate(compr, comprLen, uncompr, uncomprLen)
+
+
+