brianmario-bzip2-ruby 0.2.4 → 0.2.5

data/CHANGELOG.rdoc

@@ -0,0 +1,21 @@
+== 0.2.5 ???
+
+* initial conversion of original tests over to rspec
+
+== 0.2.4 2009-05-02
+
+* renamed BZ2 module/namespace to Bzip2
+
+== 0.2.3 2009-05-02
+
+* renamed gem to bzip2-ruby from bz2
+* initial conversion to jeweler
+* bundling gemspec
+* README and file structure organization updates
+* updated Init_*() ruby initializer function to match new gem name
+
+== 0.2.2 2008-12-22
+
+* 1 major enhancement:
+  * Gemify bz2 library from http://moulon.inra.fr/ruby/bz2.html
+  * All credit goes to Guy Decoux <ts@moulon.inra.fr>

data/README.rdoc

@@ -8,13 +8,9 @@ You may need to specify:
 
  --with-bz2-dir=<include file directory for libbzip2>
 
-== Documentation:
+== TODO
 
- coming soon...
-
-== Spec Tests:
-
- coming soon...
+* 1.9 compatibility - I could use some help with this as I think it's gonna require some Makefile trickery
 
 == Copying
  
@@ -28,3 +24,4 @@ You may need to specify:
 * Renamed BZ2 module/namespace to Bzip2
 * Renamed compiled binary from "bz2" to "bzip2"
 * Renamed gem from "bz2" to "bzip2-ruby"
+* Converted original tests to rspec

data/Rakefile

@@ -7,7 +7,7 @@ begin
     gem.email = "seniorlopez@gmail.com"
     gem.homepage = "http://github.com/brianmario/bzip2-ruby"
     gem.authors = ["Guy Decoux", "Brian Lopez"]
-    gem.require_paths = ["ext"]
+    gem.require_paths = ["lib", "ext"]
     gem.extra_rdoc_files = `git ls-files *.rdoc`.split("\n")
     gem.files = `git ls-files`.split("\n")
     gem.extensions = ["ext/extconf.rb"]

data/VERSION.yml

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

data/bzip2-ruby.gemspec

@@ -2,40 +2,41 @@
 
 Gem::Specification.new do |s|
   s.name = %q{bzip2-ruby}
-  s.version = "0.2.4"
+  s.version = "0.2.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Guy Decoux", "Brian Lopez"]
-  s.date = %q{2009-05-02}
+  s.date = %q{2009-05-18}
   s.email = %q{seniorlopez@gmail.com}
   s.extensions = ["ext/extconf.rb"]
   s.extra_rdoc_files = [
-    "README.rdoc"
+    "CHANGELOG.rdoc",
+     "README.rdoc"
   ]
   s.files = [
-    "History.txt",
-    "README.rdoc",
-    "Rakefile",
-    "VERSION.yml",
-    "bzip2-ruby.gemspec",
-    "ext/bz2.c",
-    "ext/extconf.rb",
-    "tasks/extconf.rake",
-    "tasks/extconf/bz2.rake",
-    "test/reader.rb",
-    "test/runit_.rb",
-    "test/writer.rb"
+    "CHANGELOG.rdoc",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION.yml",
+     "bzip2-ruby.gemspec",
+     "ext/bzip2.c",
+     "ext/extconf.rb",
+     "lib/bzip2.rb",
+     "spec/reader_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/writer_spec.rb",
+     "tasks/extconf.rake",
+     "tasks/extconf/bz2.rake"
   ]
-  s.has_rdoc = true
   s.homepage = %q{http://github.com/brianmario/bzip2-ruby}
   s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["ext"]
-  s.rubygems_version = %q{1.3.2}
+  s.require_paths = ["lib", "ext"]
+  s.rubygems_version = %q{1.3.3}
   s.summary = %q{Ruby C bindings to libbzip2.}
   s.test_files = [
-    "test/reader.rb",
-    "test/runit_.rb",
-    "test/writer.rb"
+    "spec/reader_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/writer_spec.rb"
   ]
 
   if s.respond_to? :specification_version then

data/ext/{bz2.c → bzip2.c}

@@ -1,7 +1,11 @@
 #include <ruby.h>
-#include <rubyio.h>
 #include <bzlib.h>
+#ifndef RUBY_19_COMPATIBILITY
+#include <rubyio.h>
 #include <version.h>
+#else
+#include <ruby/io.h>
+#endif
 
 static VALUE bz_cWriter, bz_cReader, bz_cInternal;
 static VALUE bz_eError, bz_eConfigError, bz_eEOZError;
@@ -109,18 +113,20 @@ bz_find_struct(obj, ptr, posp)
     struct bz_iv *bziv;
     int i;
 
-    for (i = 0; i < RARRAY(bz_internal_ary)->len; i++) {
-	Data_Get_Struct(RARRAY(bz_internal_ary)->ptr[i], struct bz_iv, bziv);
+    for (i = 0; i < RARRAY_LEN(bz_internal_ary); i++) {
+	Data_Get_Struct(RARRAY_PTR(bz_internal_ary)[i], struct bz_iv, bziv);
 	if (ptr) {
-	    if (TYPE(bziv->io) == T_FILE && 
-		RFILE(bziv->io)->fptr == (OpenFile *)ptr) {
-		if (posp) *posp = i;
-		return bziv;
+#ifndef RUBY_19_COMPATIBILITY
+        if (TYPE(bziv->io) == T_FILE && RFILE(bziv->io)->fptr == (OpenFile *)ptr) {
+#else
+        if (TYPE(bziv->io) == T_FILE && RFILE(bziv->io)->fptr == (rb_io_t *)ptr) {
+#endif
+		    if (posp) *posp = i;
+		    return bziv;
 	    }
-	    else if (TYPE(bziv->io) == T_DATA &&
-		     DATA_PTR(bziv->io) == ptr) {
-		if (posp) *posp = i;
-		return bziv;
+	    else if (TYPE(bziv->io) == T_DATA && DATA_PTR(bziv->io) == ptr) {
+		    if (posp) *posp = i;
+		    return bziv;
 	    }
 	}
 	else if (bziv->io == obj) {
@@ -215,8 +221,8 @@ bz_internal_finalize(ary, obj)
     struct bz_iv *bziv;
     struct bz_file *bzf;
 
-    for (i = 0; i < RARRAY(bz_internal_ary)->len; i++) {
-	elem = RARRAY(bz_internal_ary)->ptr[i];
+    for (i = 0; i < RARRAY_LEN(bz_internal_ary); i++) {
+	elem = RARRAY_PTR(bz_internal_ary)[i];
 	Data_Get_Struct(elem, struct bz_iv, bziv);
 	if (bziv->bz2) {
 	    RDATA(bziv->bz2)->dfree = ruby_xfree;
@@ -293,24 +299,35 @@ bz_io_data_finalize(ptr)
 
     bziv = bz_find_struct(0, ptr, &pos);
     if (bziv) {
-	rb_ary_delete_at(bz_internal_ary, pos);
-	Data_Get_Struct(bziv->bz2, struct bz_file, bzf);
-	rb_protect(bz_writer_internal_flush, (VALUE)bzf, 0);
-	RDATA(bziv->bz2)->dfree = ruby_xfree;
-	if (bziv->finalize) {
-	    (*bziv->finalize)(ptr);
-	}
-	else if (TYPE(bzf->io) == T_FILE) {
-	    OpenFile *file = (OpenFile *)ptr;
-	    if (file->f) {
-		fclose(file->f);
-		file->f = 0;
-	    }
-	    if (file->f2) {
-		fclose(file->f2);
-		file->f2 = 0;
-	    }
-	}
+        rb_ary_delete_at(bz_internal_ary, pos);
+        Data_Get_Struct(bziv->bz2, struct bz_file, bzf);
+        rb_protect(bz_writer_internal_flush, (VALUE)bzf, 0);
+        RDATA(bziv->bz2)->dfree = ruby_xfree;
+        if (bziv->finalize) {
+            (*bziv->finalize)(ptr);
+        } else if (TYPE(bzf->io) == T_FILE) {
+#ifndef RUBY_19_COMPATIBILITY
+            OpenFile *file = (OpenFile *)ptr;
+            if (file->f) {
+                fclose(file->f);
+                file->f = 0;
+            }
+            if (file->f2) {
+                fclose(file->f2);
+                file->f2 = 0;
+            }
+#else
+            rb_io_t *file = (rb_io_t *)ptr;
+            if (file->fd) {
+                fclose(file->fd);
+                file->fd = 0;
+            }
+            if (file->stdio_file) {
+                fclose(file->stdio_file);
+                file->stdio_file = 0;
+            }
+#endif
+        }
     }
 }
 
@@ -396,8 +413,8 @@ bz_str_write(obj, str)
     if (TYPE(str) != T_STRING) {
 	rb_raise(rb_eArgError, "expected a String");
     }
-    if (RSTRING(str)->len) {
-	rb_str_cat(obj, RSTRING(str)->ptr, RSTRING(str)->len);
+    if (RSTRING_LEN(str)) {
+	rb_str_cat(obj, RSTRING_PTR(str), RSTRING_LEN(str));
     }
     return str;
 }
@@ -436,7 +453,11 @@ bz_writer_init(argc, argv, obj)
     else {
 	VALUE iv;
 	struct bz_iv *bziv;
-	OpenFile *fptr;
+#ifndef RUBY_19_COMPATIBILITY
+    OpenFile *fptr;
+#else
+    rb_io_t *fptr;
+#endif
 
 	rb_io_taint_check(a);
 	if (!rb_respond_to(a, id_write)) {
@@ -507,8 +528,8 @@ bz_writer_write(obj, a)
 	bzf->buflen = BZ_RB_BLOCKSIZE;
 	bzf->buf[0] = bzf->buf[bzf->buflen] = '\0';
     }
-    bzf->bzs.next_in = RSTRING(a)->ptr;
-    bzf->bzs.avail_in = RSTRING(a)->len;
+    bzf->bzs.next_in = RSTRING_PTR(a);
+    bzf->bzs.avail_in = RSTRING_LEN(a);
     while (bzf->bzs.avail_in) {
 	bzf->bzs.next_out = bzf->buf;
 	bzf->bzs.avail_out = bzf->buflen;
@@ -523,7 +544,7 @@ bz_writer_write(obj, a)
 	    rb_funcall(bzf->io, id_write, 1, rb_str_new(bzf->buf, n));
 	}
     }
-    return INT2NUM(RSTRING(a)->len);
+    return INT2NUM(RSTRING_LEN(a));
 }
 
 static VALUE
@@ -614,7 +635,11 @@ bz_reader_init(argc, argv, obj)
     }
     if (rb_respond_to(a, id_read)) {
 	if (TYPE(a) == T_FILE) {
-	    OpenFile *fptr;
+#ifndef RUBY_19_COMPATIBILITY
+        OpenFile *fptr;
+#else
+        rb_io_t *fptr;
+#endif
 
 	    GetOpenFile(a, fptr);
 	    rb_io_check_readable(fptr);
@@ -691,14 +716,14 @@ bz_next_available(bzf, in)
     }
     if (!bzf->bzs.avail_in) {
 	bzf->in = rb_funcall(bzf->io, id_read, 1, INT2FIX(1024));
-	if (TYPE(bzf->in) != T_STRING || RSTRING(bzf->in)->len == 0) {
+	if (TYPE(bzf->in) != T_STRING || RSTRING_LEN(bzf->in) == 0) {
 	    BZ2_bzDecompressEnd(&(bzf->bzs));
 	    bzf->bzs.avail_out = 0;
 	    bzf->state = BZ_UNEXPECTED_EOF;
 	    bz_raise(bzf->state);
 	}
-	bzf->bzs.next_in = RSTRING(bzf->in)->ptr;
-	bzf->bzs.avail_in = RSTRING(bzf->in)->len;
+	bzf->bzs.next_in = RSTRING_PTR(bzf->in);
+	bzf->bzs.avail_in = RSTRING_LEN(bzf->in);
     }
     if ((bzf->buflen - in) < (BZ_RB_BLOCKSIZE / 2)) {
 	bzf->buf = REALLOC_N(bzf->buf, char, bzf->buflen+BZ_RB_BLOCKSIZE+1);
@@ -780,7 +805,7 @@ bz_read_until(bzf, str, len, td1)
 	    if (nex) {
 		res = rb_str_cat(res, bzf->buf, nex);
 	    }
-	    if (RSTRING(res)->len) {
+	    if (RSTRING_LEN(res)) {
 		return res;
 	    }
 	    return Qnil;
@@ -845,8 +870,8 @@ bz_reader_read(argc, argv, obj)
     }
     while (1) {
 	total = bzf->bzs.avail_out;
-	if (n != -1 && (RSTRING(res)->len + total) >= n) {
-	    n -= RSTRING(res)->len;
+	if (n != -1 && (RSTRING_LEN(res) + total) >= n) {
+	    n -= RSTRING_LEN(res);
 	    res = rb_str_cat(res, bzf->bzs.next_out, n);
 	    bzf->bzs.next_out += n;
 	    bzf->bzs.avail_out -= n;
@@ -868,10 +893,10 @@ bz_getc(obj)
 {
     VALUE length = INT2FIX(1);
     VALUE res = bz_reader_read(1, &length, obj);
-    if (NIL_P(res) || RSTRING(res)->len == 0) {
+    if (NIL_P(res) || RSTRING_LEN(res) == 0) {
 	return EOF;
     }
-    return RSTRING(res)->ptr[0];
+    return RSTRING_PTR(res)[0];
 }
 
 static VALUE
@@ -911,15 +936,15 @@ bz_reader_ungets(obj, a)
     if (!bzf->buf) {
 	bz_raise(BZ_SEQUENCE_ERROR);
     }
-    if ((bzf->bzs.avail_out + RSTRING(a)->len) < bzf->buflen) {
-	bzf->bzs.next_out -= RSTRING(a)->len;
-	MEMCPY(bzf->bzs.next_out, RSTRING(a)->ptr, char, RSTRING(a)->len);
-	bzf->bzs.avail_out += RSTRING(a)->len;
+    if ((bzf->bzs.avail_out + RSTRING_LEN(a)) < bzf->buflen) {
+	bzf->bzs.next_out -= RSTRING_LEN(a);
+	MEMCPY(bzf->bzs.next_out, RSTRING_PTR(a), char, RSTRING_LEN(a));
+	bzf->bzs.avail_out += RSTRING_LEN(a);
     }
     else {
-	bzf->buf = REALLOC_N(bzf->buf, char, bzf->buflen + RSTRING(a)->len + 1);
-	MEMCPY(bzf->buf + bzf->buflen, RSTRING(a)->ptr, char,RSTRING(a)->len);
-	bzf->buflen += RSTRING(a)->len;
+	bzf->buf = REALLOC_N(bzf->buf, char, bzf->buflen + RSTRING_LEN(a) + 1);
+	MEMCPY(bzf->buf + bzf->buflen, RSTRING_PTR(a), char,RSTRING_LEN(a));
+	bzf->buflen += RSTRING_LEN(a);
 	bzf->buf[bzf->buflen] = '\0';
 	bzf->bzs.next_out = bzf->buf;
 	bzf->bzs.avail_out = bzf->buflen;
@@ -966,8 +991,8 @@ bz_reader_gets_internal(argc, argv, obj, td, init)
     if (NIL_P(rs)) {
 	return bz_reader_read(1, &rs, obj);
     }
-    rslen = RSTRING(rs)->len;
-    if (rs == rb_default_rs || (rslen == 1 && RSTRING(rs)->ptr[0] == '\n')) {
+    rslen = RSTRING_LEN(rs);
+    if (rs == rb_default_rs || (rslen == 1 && RSTRING_PTR(rs)[0] == '\n')) {
 	return bz_reader_gets(obj);
     }
 
@@ -977,7 +1002,7 @@ bz_reader_gets_internal(argc, argv, obj, td, init)
 	rspara = 1;
     }
     else {
-	rsptr = RSTRING(rs)->ptr;
+	rsptr = RSTRING_PTR(rs);
 	rspara = 0;
     }
 
@@ -1024,13 +1049,13 @@ bz_reader_set_unused(obj, a)
     Check_Type(a, T_STRING);
     Get_BZ2(obj, bzf);
     if (!bzf->in) {
-	bzf->in = rb_str_new(RSTRING(a)->ptr, RSTRING(a)->len);
+	bzf->in = rb_str_new(RSTRING_PTR(a), RSTRING_LEN(a));
     }
     else {
-	bzf->in = rb_str_cat(bzf->in, RSTRING(a)->ptr, RSTRING(a)->len);
+	bzf->in = rb_str_cat(bzf->in, RSTRING_PTR(a), RSTRING_LEN(a));
     }
-    bzf->bzs.next_in = RSTRING(bzf->in)->ptr;
-    bzf->bzs.avail_in = RSTRING(bzf->in)->len;
+    bzf->bzs.next_in = RSTRING_PTR(bzf->in);
+    bzf->bzs.avail_in = RSTRING_LEN(bzf->in);
     return Qnil;
 }
 
@@ -1042,10 +1067,10 @@ bz_reader_getc(obj)
     VALUE len = INT2FIX(1);
 
     str = bz_reader_read(1, &len, obj);
-    if (NIL_P(str) || RSTRING(str)->len == 0) {
+    if (NIL_P(str) || RSTRING_LEN(str) == 0) {
 	return Qnil;
     }
-    return INT2FIX(RSTRING(str)->ptr[0] & 0xff);
+    return INT2FIX(RSTRING_PTR(str)[0] & 0xff);
 }
 
 static void
@@ -1411,7 +1436,7 @@ bz_str_read(argc, argv, obj)
     Data_Get_Struct(obj, struct bz_str, bzs);
     rb_scan_args(argc, argv, "01", &len);
     if (NIL_P(len)) {
-	count = RSTRING(bzs->str)->len;
+	count = RSTRING_LEN(bzs->str);
     }
     else {
 	count = NUM2INT(len);
@@ -1422,13 +1447,13 @@ bz_str_read(argc, argv, obj)
     if (!count || bzs->pos == -1) {
 	return Qnil;
     }
-    if ((bzs->pos + count) >= RSTRING(bzs->str)->len) {
-	res = rb_str_new(RSTRING(bzs->str)->ptr + bzs->pos, 
-			 RSTRING(bzs->str)->len - bzs->pos);
+    if ((bzs->pos + count) >= RSTRING_LEN(bzs->str)) {
+	res = rb_str_new(RSTRING_PTR(bzs->str) + bzs->pos, 
+			 RSTRING_LEN(bzs->str) - bzs->pos);
 	bzs->pos = -1;
     }
     else {
-	res = rb_str_new(RSTRING(bzs->str)->ptr + bzs->pos, count);
+	res = rb_str_new(RSTRING_PTR(bzs->str) + bzs->pos, count);
 	bzs->pos += count;
     }
     return res;
@@ -1471,12 +1496,12 @@ bz_proc_new(func, val)
                        rb_intern("to_proc"), 0, 0);
 }
 
-void Init_bzip2()
+void Init_bzip2_ext()
 {
     VALUE bz_mBzip2;
 
     if (rb_const_defined_at(rb_cObject, rb_intern("Bzip2"))) {
-	rb_raise(rb_eNameError, "module already defined");
+        rb_raise(rb_eNameError, "module already defined");
     }
 
     bz_internal_ary = rb_ary_new();

data/ext/extconf.rb

@@ -7,7 +7,12 @@ if have_library("bz2", "BZ2_bzWriteOpen")
   if enable_config("shared", true)
      $static = nil
   end
-  create_makefile("bzip2")
+  
+  if RUBY_VERSION =~ /1.9/
+    $CFLAGS << ' -DRUBY_19_COMPATIBILITY'
+  end
+  
+  create_makefile("bzip2_ext")
 else
   puts "libbz2 not found, maybe try manually specifying --with-bz2-dir to find it?"
 end