bzip2-ruby 0.2.3 → 0.2.4

data/README.rdoc

@@ -21,3 +21,10 @@ You may need to specify:
  This extension module is copyrighted free software by Guy Decoux
  You can redistribute it and/or modify it under the same term as Ruby.
  Guy Decoux <ts@moulon.inra.fr>
+
+== Modifications from origin version
+
+* Switch to Jeweler
+* Renamed BZ2 module/namespace to Bzip2
+* Renamed compiled binary from "bz2" to "bzip2"
+* Renamed gem from "bz2" to "bzip2-ruby"

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:patch: 3
+:patch: 4
 :major: 0
 :minor: 2

data/bzip2-ruby.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{bzip2-ruby}
-  s.version = "0.2.3"
+  s.version = "0.2.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Guy Decoux", "Brian Lopez"]

data/ext/bz2.c

@@ -1473,9 +1473,9 @@ bz_proc_new(func, val)
 
 void Init_bzip2()
 {
-    VALUE bz_mBZ2;
+    VALUE bz_mBzip2;
 
-    if (rb_const_defined_at(rb_cObject, rb_intern("BZ2"))) {
+    if (rb_const_defined_at(rb_cObject, rb_intern("Bzip2"))) {
 	rb_raise(rb_eNameError, "module already defined");
     }
 
@@ -1494,20 +1494,20 @@ void Init_bzip2()
     id_closed = rb_intern("closed?");
     id_str = rb_intern("to_str");
 
-    bz_mBZ2 = rb_define_module("BZ2");
-    bz_eConfigError = rb_define_class_under(bz_mBZ2, "ConfigError", rb_eFatal);
-    bz_eError = rb_define_class_under(bz_mBZ2, "Error", rb_eIOError);
-    bz_eEOZError = rb_define_class_under(bz_mBZ2, "EOZError", bz_eError);
+    bz_mBzip2 = rb_define_module("Bzip2");
+    bz_eConfigError = rb_define_class_under(bz_mBzip2, "ConfigError", rb_eFatal);
+    bz_eError = rb_define_class_under(bz_mBzip2, "Error", rb_eIOError);
+    bz_eEOZError = rb_define_class_under(bz_mBzip2, "EOZError", bz_eError);
 
-    rb_define_module_function(bz_mBZ2, "compress", bz_compress, -1);
-    rb_define_module_function(bz_mBZ2, "uncompress", bz_uncompress, -1);
-    rb_define_module_function(bz_mBZ2, "decompress", bz_uncompress, -1);
-    rb_define_module_function(bz_mBZ2, "bzip2", bz_compress, -1);
-    rb_define_module_function(bz_mBZ2, "bunzip2", bz_uncompress, -1);
+    rb_define_module_function(bz_mBzip2, "compress", bz_compress, -1);
+    rb_define_module_function(bz_mBzip2, "uncompress", bz_uncompress, -1);
+    rb_define_module_function(bz_mBzip2, "decompress", bz_uncompress, -1);
+    rb_define_module_function(bz_mBzip2, "bzip2", bz_compress, -1);
+    rb_define_module_function(bz_mBzip2, "bunzip2", bz_uncompress, -1);
     /*
       Writer
     */
-    bz_cWriter = rb_define_class_under(bz_mBZ2, "Writer", rb_cData);
+    bz_cWriter = rb_define_class_under(bz_mBzip2, "Writer", rb_cData);
 #if HAVE_RB_DEFINE_ALLOC_FUNC
     rb_define_alloc_func(bz_cWriter, bz_writer_s_alloc);
 #else
@@ -1530,7 +1530,7 @@ void Init_bzip2()
     /*
       Reader
     */
-    bz_cReader = rb_define_class_under(bz_mBZ2, "Reader", rb_cData);
+    bz_cReader = rb_define_class_under(bz_mBzip2, "Reader", rb_cData);
     rb_include_module(bz_cReader, rb_mEnumerable);
 #if HAVE_RB_DEFINE_ALLOC_FUNC
     rb_define_alloc_func(bz_cReader, bz_reader_s_alloc);
@@ -1570,7 +1570,7 @@ void Init_bzip2()
     /*
       Internal
     */
-    bz_cInternal = rb_define_class_under(bz_mBZ2, "InternalStr", rb_cData);
+    bz_cInternal = rb_define_class_under(bz_mBzip2, "InternalStr", rb_cData);
 #if HAVE_RB_DEFINE_ALLOC_FUNC
     rb_undef_alloc_func(bz_cInternal);
 #else

data/test/reader.rb

@@ -3,7 +3,8 @@
 # This is the test from rubicon
 
 $LOAD_PATH.unshift(*%w{.. tests})
-require 'bz2'
+require 'rubygems'
+require 'bzip2'
 require 'runit_'
 
 Inh = defined?(RUNIT) ? RUNIT : Test::Unit
@@ -32,7 +33,7 @@ class TestReader < Inh::TestCase
 
    def test_f_s_foreach
       count = 0
-      BZ2::Reader.foreach($file) do |line|
+      Bzip2::Reader.foreach($file) do |line|
 	 num = line[0..1].to_i
 	 assert_equal(count, num)
 	 count += 1
@@ -40,7 +41,7 @@ class TestReader < Inh::TestCase
       assert_equal($data.size, count)
       
       count = 0
-      BZ2::Reader.foreach($file, nil) do |file|
+      Bzip2::Reader.foreach($file, nil) do |file|
 	 file.split(/\n/).each do |line|
 	    num = line[0..1].to_i
 	    assert_equal(count, num)
@@ -50,23 +51,23 @@ class TestReader < Inh::TestCase
       assert_equal($data.size, count)
 
       count = 0
-      BZ2::Reader.foreach($file, ' ') do |thing|
+      Bzip2::Reader.foreach($file, ' ') do |thing|
 	 count += 1
       end
       assert_equal(41, count)
    end
 
    def test_f_s_readlines
-      lines = BZ2::Reader.readlines($file)
+      lines = Bzip2::Reader.readlines($file)
       assert_equal($data.size, lines.size)
 
-      lines = BZ2::Reader.readlines($file, nil)
+      lines = Bzip2::Reader.readlines($file, nil)
       assert_equal(1, lines.size)
       assert_equal(SAMPLE.length * $data.size, lines[0].size)
    end
 
    def test_f_closed?
-      f = BZ2::Reader.open($file)
+      f = Bzip2::Reader.open($file)
       assert(!f.closed?)
       f.close
       assert(f.closed?)
@@ -74,7 +75,7 @@ class TestReader < Inh::TestCase
 
    def test_f_each
       count = 0
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 file.each do |line|
 	    num = line[0..1].to_i
 	    assert_equal(count, num)
@@ -84,7 +85,7 @@ class TestReader < Inh::TestCase
       end
 
       count = 0
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 file.each(nil) do |contents|
 	    contents.split(/\n/).each do |line|
 	       num = line[0..1].to_i
@@ -96,7 +97,7 @@ class TestReader < Inh::TestCase
       assert_equal($data.size, count)
 
       count = 0
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 file.each(' ') do |thing|
 	    count += 1
 	 end
@@ -108,7 +109,7 @@ class TestReader < Inh::TestCase
       count = 0
       data = $data.join
 
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 file.each_byte do |b|
 	    assert_equal(data[count], b)
 	    count += 1
@@ -119,7 +120,7 @@ class TestReader < Inh::TestCase
 
    def test_f_each_line
       count = 0
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 file.each_line do |line|
 	    num = line[0..1].to_i
 	    assert_equal(count, num)
@@ -129,7 +130,7 @@ class TestReader < Inh::TestCase
       end
 
       count = 0
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 file.each_line(nil) do |contents|
 	    contents.split(/\n/).each do |line|
 	       num = line[0..1].to_i
@@ -141,7 +142,7 @@ class TestReader < Inh::TestCase
       assert_equal($data.size, count)
 
       count = 0
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 file.each_line(' ') do |thing|
 	    count += 1
 	 end
@@ -150,7 +151,7 @@ class TestReader < Inh::TestCase
    end
 
    def test_f_eof
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 $data.size.times do
 	    assert(!file.eof)
 	    assert(!file.eof?)
@@ -165,7 +166,7 @@ class TestReader < Inh::TestCase
       count = 0
       data = $data.join
       
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 while (ch = file.getc)
 	    assert_equal(data[count], ch)
 	    count += 1
@@ -177,7 +178,7 @@ class TestReader < Inh::TestCase
 
    def test_f_gets
       count = 0
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 while (line = file.gets)
 	    num = line[0..1].to_i
 	    assert_equal(count, num)
@@ -188,7 +189,7 @@ class TestReader < Inh::TestCase
       end
 
       count = 0
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 while (line = file.gets("line\n"))
 	    assert_equal($data[count], line)
 	    num = line[0..1].to_i
@@ -200,7 +201,7 @@ class TestReader < Inh::TestCase
       end
 
       count = 0
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 while (contents = file.gets(nil))
 	    contents.split(/\n/).each do |line|
 	       num = line[0..1].to_i
@@ -212,7 +213,7 @@ class TestReader < Inh::TestCase
       assert_equal($data.size, count)
 
       count = 0
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 while (thing = file.gets(' '))
 	    count += 1
 	 end
@@ -221,7 +222,7 @@ class TestReader < Inh::TestCase
    end
 
    def test_f_read
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 content = file.read
 	 assert_equal(SAMPLE.length * $data.size, content.length)
 	 count = 0
@@ -232,7 +233,7 @@ class TestReader < Inh::TestCase
 	 end
       end
 
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 assert_equal("00: This is ", file.read(12))
 	 assert_equal("a line\n01: T", file.read(12))
       end
@@ -241,57 +242,57 @@ class TestReader < Inh::TestCase
    def test_f_readchar
       count = 0
       data = $data.join
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 190.times do |count|
 	    ch = file.readchar
 	    assert_equal(data[count], ch)
 	    count += 1
 	 end
-	 assert_raises(BZ2::EOZError) { file.readchar }
+	 assert_raises(Bzip2::EOZError) { file.readchar }
       end
    end
 
    def test_f_readline
       count = 0
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 $data.size.times do |count|
 	    line = file.readline
 	    num = line[0..1].to_i
 	    assert_equal(count, num)
 	    count += 1
 	 end
-	 assert_raises(BZ2::EOZError) { file.readline }
+	 assert_raises(Bzip2::EOZError) { file.readline }
       end
 
       count = 0
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 contents = file.readline(nil)
 	 contents.split(/\n/).each do |line|
 	    num = line[0..1].to_i
 	    assert_equal(count, num)
 	    count += 1
 	 end
-	 assert_raises(BZ2::EOZError) { file.readline }
+	 assert_raises(Bzip2::EOZError) { file.readline }
       end
       assert_equal($data.size, count)
 
       count = 0
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 41.times do |count|
 	    thing = file.readline(' ')
 	    count += 1
 	 end
-	 assert_raises(BZ2::EOZError) { file.readline }
+	 assert_raises(Bzip2::EOZError) { file.readline }
       end
    end
 
    def test_f_readlines
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 lines = file.readlines
 	 assert_equal($data.size, lines.size)
       end
       
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 lines = file.readlines(nil)
 	 assert_equal(1, lines.size)
 	 assert_equal(SAMPLE.length * $data.size, lines[0].size)
@@ -299,7 +300,7 @@ class TestReader < Inh::TestCase
    end
 
    def test_f_ungetc
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 assert_equal(?0, file.getc)
 	 assert_equal(?0, file.getc)
 	 assert_equal(?:, file.getc)
@@ -314,7 +315,7 @@ class TestReader < Inh::TestCase
    
    def test_f_ungets
       count = 0
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 assert_equal($data[count], file.gets)
 	 assert_equal(count + 1, file.lineno);
 	 assert_nil(file.ungets($data[count]))
@@ -326,35 +327,35 @@ class TestReader < Inh::TestCase
    def test_s_readline
       count = 0
       string = IO.readlines($file, nil)[0]
-      file = BZ2::Reader.new(string)
+      file = Bzip2::Reader.new(string)
       $data.size.times do |count|
 	 line = file.readline
 	 num = line[0..1].to_i
 	 assert_equal(count, num)
 	 count += 1
       end
-      assert_raises(BZ2::EOZError) { file.readline }
+      assert_raises(Bzip2::EOZError) { file.readline }
       file.close
 
       count = 0
-      file = BZ2::Reader.new(string)
+      file = Bzip2::Reader.new(string)
       contents = file.readline(nil)
       contents.split(/\n/).each do |line|
 	 num = line[0..1].to_i
 	 assert_equal(count, num)
 	 count += 1
       end
-      assert_raises(BZ2::EOZError) { file.readline }
+      assert_raises(Bzip2::EOZError) { file.readline }
       assert_equal($data.size, count)
       file.close
 
       count = 0
-      file = BZ2::Reader.new(string)
+      file = Bzip2::Reader.new(string)
       41.times do |count|
 	 thing = file.readline(' ')
 	 count += 1
       end
-      assert_raises(BZ2::EOZError) { file.readline }
+      assert_raises(Bzip2::EOZError) { file.readline }
       file.close
    end
 

data/test/writer.rb

@@ -3,7 +3,8 @@
 # This is the test from rubicon
 
 $LOAD_PATH.unshift(*%w{.. tests})
-require 'bz2'
+require 'rubygems'
+require 'bzip2'
 require 'runit_'
 
 Inh = defined?(RUNIT) ? RUNIT : Test::Unit
@@ -19,11 +20,11 @@ end
 class TestWriter < Inh::TestCase
 
    def test_f_LSHIFT # '<<'
-      BZ2::Writer.open($file, "w") do |file|
+      Bzip2::Writer.open($file, "w") do |file|
 	 file << 1 << "\n" << Dummy.new << "\n" << "cat\n"
       end
       expected = [ "1\n", "dummy\n", "cat\n"]
-      BZ2::Reader.foreach($file) do |line|
+      Bzip2::Reader.foreach($file) do |line|
 	 assert_equal(expected.shift, line)
       end
       assert_equal([], expected)
@@ -31,21 +32,21 @@ class TestWriter < Inh::TestCase
 
    def test_f_error
       io = File.new($file, "w")
-      bz2 = BZ2::Writer.new(io)
+      bz2 = Bzip2::Writer.new(io)
       bz2 << 1 << "\n" << Dummy.new << "\n" << "cat\n"
-      bz = BZ2::Reader.new($file)
-      assert_raises(BZ2::Error) { bz.gets }
-      bz = BZ2::Reader.open($file)
-      assert_raises(BZ2::EOZError) { bz.gets }
+      bz = Bzip2::Reader.new($file)
+      assert_raises(Bzip2::Error) { bz.gets }
+      bz = Bzip2::Reader.open($file)
+      assert_raises(Bzip2::EOZError) { bz.gets }
       io.close
-      assert_raises(IOError) { BZ2::Reader.new(io) }
+      assert_raises(IOError) { Bzip2::Reader.new(io) }
    end
 
    def test_f_gets_para
-      BZ2::Writer.open($file) do |file|
+      Bzip2::Writer.open($file) do |file|
 	 file.print "foo\n"*4096, "\n"*4096, "bar"*4096, "\n"*4096, "zot\n"*1024
       end
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 assert_equal("foo\n"*4096+"\n", file.gets(""))
 	 assert_equal("bar"*4096+"\n\n", file.gets(""))
 	 assert_equal("zot\n"*1024, file.gets(""))
@@ -53,7 +54,7 @@ class TestWriter < Inh::TestCase
    end
 
    def test_f_print
-      BZ2::Writer.open($file) do |file|
+      Bzip2::Writer.open($file) do |file|
 	 file.print "hello"
 	 file.print 1,2
 	 $_ = "wombat\n"
@@ -67,31 +68,31 @@ class TestWriter < Inh::TestCase
 	 $, = nil
       end
 
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 content = file.gets(nil)
 	 assert_equal("hello12wombat\n3,4:5,6:\n", content)
       end
    end
 
    def test_f_putc
-      BZ2::Writer.open($file, "wb") do |file|
+      Bzip2::Writer.open($file, "wb") do |file|
 	 file.putc "A"
 	 0.upto(255) { |ch| file.putc ch }
       end
 
-      BZ2::Reader.open($file, "rb") do |file|
+      Bzip2::Reader.open($file, "rb") do |file|
 	 assert_equal(?A, file.getc)
 	 0.upto(255) { |ch| assert_equal(ch, file.getc) }
       end
    end
 
    def test_f_puts
-      BZ2::Writer.open($file, "w") do |file|
+      Bzip2::Writer.open($file, "w") do |file|
 	 file.puts "line 1", "line 2"
 	 file.puts [ Dummy.new, 4 ]
       end
 
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 assert_equal("line 1\n",  file.gets)
 	 assert_equal("line 2\n",  file.gets)
 	 assert_equal("dummy\n",   file.gets)
@@ -100,7 +101,7 @@ class TestWriter < Inh::TestCase
    end
 
    def test_f_write
-      BZ2::Writer.open($file, "w") do |file|
+      Bzip2::Writer.open($file, "w") do |file|
 	 assert_equal(10, file.write('*' * 10))
 	 assert_equal(5,  file.write('!' * 5))
 	 assert_equal(0,  file.write(''))
@@ -109,33 +110,33 @@ class TestWriter < Inh::TestCase
 	 assert_equal(1,  file.write("\n"))
       end
     
-      BZ2::Reader.open($file) do |file|
+      Bzip2::Reader.open($file) do |file|
 	 assert_equal("**********!!!!!12.3\n", file.gets)
       end
    end
 
    def test_s_string
-      file = BZ2::Writer.new
+      file = Bzip2::Writer.new
       assert_equal(10, file.write('*' * 10))
       assert_equal(5,  file.write('!' * 5))
       assert_equal(0,  file.write(''))
       assert_equal(1,  file.write(1))
       assert_equal(3,  file.write(2.30000))
       assert_equal(1,  file.write("\n"))
-      line = BZ2::bunzip2(file.flush)
+      line = Bzip2::bunzip2(file.flush)
       assert_equal("**********!!!!!12.3\n", line)
 
-      line = BZ2::bunzip2(BZ2::bzip2("**********!!!!!12.3\n"))
+      line = Bzip2::bunzip2(Bzip2::bzip2("**********!!!!!12.3\n"))
       assert_equal("**********!!!!!12.3\n", line)
 
       test = "foo\n"*4096 + "\n"*4096 + "bar"*4096 + "\n"*4096 + "zot\n"*1024
-      line = BZ2::bunzip2(BZ2::bzip2(test))
+      line = Bzip2::bunzip2(Bzip2::bzip2(test))
       assert_equal(test, line)
 
-      assert(BZ2::bzip2("aaaaaaaaa".taint).tainted?)
-      assert(BZ2::bunzip2(BZ2::bzip2("aaaaaaaaa".taint)).tainted?)
-      assert(!BZ2::bzip2("aaaaaaaaa").tainted?)
-      assert(!BZ2::bunzip2(BZ2::bzip2("aaaaaaaaa")).tainted?)
+      assert(Bzip2::bzip2("aaaaaaaaa".taint).tainted?)
+      assert(Bzip2::bunzip2(Bzip2::bzip2("aaaaaaaaa".taint)).tainted?)
+      assert(!Bzip2::bzip2("aaaaaaaaa").tainted?)
+      assert(!Bzip2::bunzip2(Bzip2::bzip2("aaaaaaaaa")).tainted?)
 
    end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bzip2-ruby
 version: !ruby/object:Gem::Version 
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors: 
 - Guy Decoux