oil 0.0.2 → 0.0.3

data/README.rdoc

@@ -4,7 +4,8 @@ http://github.com/ender672/oil
 
 == DESCRIPTION:
 
-Oil resizes JPEG and PNG images.
+Oil resizes JPEG and PNG images. It aims for fast performance and low memory
+use.
 
 == INSTALLATION:
 
@@ -23,6 +24,8 @@ Oil resizes JPEG and PNG images.
 
 == REQUIREMENTS:
 
+These requirements do not apply to the JRuby gem.
+
 * IJG JPEG Library or libjpeg-turbo.
 * libpng
 
@@ -43,8 +46,8 @@ Compile & run unit tests. Should show no warnings and no failing tests:
 
 Valgrind should not complain (ruby-1.9.3p125, compiled with -O3):
 
-  $ valgrind /path/to/ruby -Iext test/test_jpeg.rb
-  $ valgrind --suppressions=test/valgrind_suppressions.txt /path/to/ruby -Iext test/test_png.rb
+  $ valgrind /path/to/ruby -Iext:test test/test_jpeg.rb
+  $ valgrind --suppressions=test/valgrind_suppressions.txt /path/to/ruby -Iext:test test/test_png.rb
 
 Tests should not leak memory:
 
@@ -56,7 +59,7 @@ Changes to the interpolator should be analyzed using ResampleScope:
 
 == TODO:
 
-* JRuby
+* Windows
 
 == LICENSE:
 

data/Rakefile

@@ -1,6 +1,14 @@
 require 'rake/clean'
 require 'rake/testtask'
 
+file 'ext/oil.jar' => FileList['ext/*.java'] do
+  cd 'ext' do
+    sh "javac -g -cp #{Config::CONFIG['prefix']}/lib/jruby.jar #{FileList['*.java']}"
+    quoted_files = (FileList.new('*.class').to_a.map { |f| "'#{f}'" }).join(' ')
+    sh "jar cf oil.jar #{quoted_files}"
+  end
+end
+
 file 'ext/Makefile' do
   cd 'ext' do
     ruby "extconf.rb #{ENV['EXTOPTS']}"
@@ -14,15 +22,20 @@ file 'ext/oil.so' => FileList.new('ext/Makefile', 'ext/oil.c') do
 end
 
 Rake::TestTask.new do |t|
-  t.libs = ['ext']
-  t.test_files = FileList['test/test*.rb']
+  t.libs = ['ext', 'test']
+  t.test_files = FileList['test/test_*.rb']
 end
 
-CLEAN.add('ext/*{.o,.so,.log}', 'ext/Makefile')
+CLEAN.add('ext/*{.o,.so,.log,.class,.jar}', 'ext/Makefile')
 CLOBBER.add('*.gem')
 
+desc 'Build the gem and include the java library'
+task :gem => "ext/oil.jar" do
+  system "gem build oil.gemspec"
+end
+
 desc 'Compile the extension'
-task :compile => "ext/oil.so"
+task :compile => "ext/oil.#{RUBY_PLATFORM =~ /java/ ? 'jar' : 'so'}"
 
 task :test => :compile
 task :default => :test

data/ext/oil.c

@@ -8,8 +8,8 @@ static ID id_read, id_seek;
 
 struct thumbdata {
     VALUE io;
-    long width;
-    long height;
+    unsigned int width;
+    unsigned int height;
 };
 
 static struct jpeg_error_mgr jerr;
@@ -31,16 +31,32 @@ struct png_src {
 };
 
 struct interpolation {
-  long sw;
-  long sh;
-  long dw;
-  long dh;
-  int cmp;
-  void (*read)(char *, void *);
-  void (*write)(char *, void *);
-  void *data;
+    long sw;
+    long sh;
+    long dw;
+    long dh;
+    int cmp;
+    void (*read)(char *, void *);
+    void (*write)(char *, void *);
+    void *read_data;
+    void *write_data;
 };
 
+struct bitmap {
+    long rowlen;
+    char *cur;
+};
+
+/* bitmap source callback */
+
+static void
+bitmap_read(char *sl, void *data)
+{
+    struct bitmap *b = (struct bitmap *)data;
+    memcpy(sl, b->cur, b->rowlen);
+    b->cur += b->rowlen;
+}
+
 /* jpeglib error callbacks */
 
 static void output_message(j_common_ptr cinfo) {}
@@ -147,17 +163,19 @@ png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
 void
 png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
 {
-    VALUE string;
+    VALUE ret, buf;
     png_size_t rlen;
     struct png_src *io_ptr;
 
     if (!png_ptr) return;
     io_ptr = (struct png_src *)png_get_io_ptr(png_ptr);
-    string = io_ptr->buffer;
-    rb_funcall(io_ptr->io, id_read, 2, INT2FIX(length), string);
-    rlen = RSTRING_LEN(string);
-    if (rlen > length) rb_raise(rb_eRuntimeError, "IO return buffer is too big.");
-    memcpy(data, RSTRING_PTR(string), RSTRING_LEN(string));
+    buf = io_ptr->buffer;
+    ret = rb_funcall(io_ptr->io, id_read, 2, INT2FIX(length), buf);
+
+    rlen = RSTRING_LEN(buf);
+    if (rlen > length)
+	rb_raise(rb_eRuntimeError, "IO return buffer is too big.");
+    if (!NIL_P(ret)) memcpy(data, RSTRING_PTR(buf), rlen);
 }
 
 /* png read/write callbacks */
@@ -165,15 +183,13 @@ png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
 static void
 png_read(char *sl, void *data)
 {
-    void **data_ary = (void **)data;
-    png_read_row((png_structp)data_ary[2], (png_bytep)sl, (png_bytep)NULL);
+    png_read_row((png_structp)data, (png_bytep)sl, (png_bytep)NULL);
 }
 
 static void
 png_write(char *sl, void *data)
 {
-    void **data_ary = (void **)data;
-    png_write_row((png_structp)*data_ary, (png_bytep)sl);
+    png_write_row((png_structp)data, (png_bytep)sl);
 }
 
 /* Bilinear Interpolation */
@@ -189,12 +205,12 @@ bilinear_get_scanlines(struct interpolation *bi, char **sl1, char **sl2,
     n = line + 1 - *next;
     if (line < bi->sh - 1) n++;
     *next += n;
-    
+
     for (i=0; i<n; i++) {
 	tmp = *sl1;
 	*sl1 = *sl2;
 	*sl2 = tmp;
-	bi->read(*sl2, bi->data);
+	bi->read(*sl2, bi->read_data);
 
 	for (j=0; j<bi->cmp; j++)
 	    sl2[0][len + bi->cmp - j] = sl2[0][len - j];
@@ -212,12 +228,15 @@ bilinear3(char *sl1, char *sl2, char *sl_out, size_t sw, size_t dw, int cmp,
     size_t xsmp_i, i, j;
     double xscale_inv, xscale_ctr, ty;
     
+    if (ysmp < 0) ysmp = 0;
+
     xscale_inv = sw / (float)dw;
     xscale_ctr = (xscale_inv - 1) / 2;
     ty = ysmp - (int)ysmp;
 
     for (i = 0; i < dw; i++) {
 	xsmp = i * xscale_inv + xscale_ctr;
+	if (xsmp < 0) xsmp = 0;
 	xsmp_i = (int)xsmp;
 
 	tx = xsmp - xsmp_i;
@@ -255,7 +274,7 @@ bilinear2(VALUE _args)
 
 	bilinear_get_scanlines(bi, &sl1, &sl2, &line, ysmp);
 	bilinear3(sl1, sl2, sl_out, bi->sw, bi->dw, bi->cmp, ysmp);
-	bi->write(sl_out, bi->data);
+	bi->write(sl_out, bi->write_data);
     }
 
     return Qnil;
@@ -286,20 +305,22 @@ bilinear(struct interpolation *bi)
     if (state) rb_jump_tag(state);
 }
 
-/* JPEG helper functions */
+/* helper functions */
 
 static void
-jpeg_fix_aspect_ratio(j_compress_ptr cinfo, j_decompress_ptr dinfo)
+fix_ratio(unsigned int sw, unsigned int sh, unsigned int *dw, unsigned int *dh)
 {
     double x, y;
-
-    x = cinfo->image_width / (float)dinfo->output_width;
-    y = cinfo->image_height / (float)dinfo->output_height;
-    
-    if (x < y) cinfo->image_height = dinfo->output_height * x;
-    else cinfo->image_width = dinfo->output_width * y;
+    x = *dw / (float)sw;
+    y = *dh / (float)sh;
+    if (x<y) *dh = sh * x;
+    else *dw = sw * y;
+    if (!*dh) *dh = 1;
+    if (!*dw) *dw = 1;
 }
 
+/* jpeg helper functions */
+
 static void
 jpeg_set_output_header(j_compress_ptr cinfo, j_decompress_ptr dinfo)
 {
@@ -322,15 +343,13 @@ jpeg_pre_scale(j_compress_ptr cinfo, j_decompress_ptr dinfo)
 static void
 jpeg_read(char *sl, void *data)
 {
-    void **data_ary = (void **)data;
-    jpeg_read_scanlines((j_decompress_ptr)*data_ary, (JSAMPROW *)&sl, 1);
+    jpeg_read_scanlines((j_decompress_ptr)data, (JSAMPROW *)&sl, 1);
 }
 
 static void
 jpeg_write(char *sl, void *data)
 {
-    void **data_ary = (void **)data;
-    jpeg_write_scanlines((j_compress_ptr)data_ary[1], (JSAMPROW *)&sl, 1);
+    jpeg_write_scanlines((j_compress_ptr)data, (JSAMPROW *)&sl, 1);
 }
 
 static VALUE
@@ -340,12 +359,12 @@ jpeg_each3(VALUE _args)
     j_decompress_ptr dinfo = (j_decompress_ptr)args[0];
     j_compress_ptr cinfo = (j_compress_ptr)args[1];
     struct interpolation intrp;
-    void *data[2];
 
     jpeg_read_header(dinfo, TRUE);
     jpeg_calc_output_dimensions(dinfo);
     jpeg_set_output_header(cinfo, dinfo);
-    jpeg_fix_aspect_ratio(cinfo, dinfo);
+    fix_ratio(dinfo->output_width, dinfo->output_height, &cinfo->image_width,
+	      &cinfo->image_height);
     jpeg_pre_scale(cinfo, dinfo);
 
     jpeg_start_compress(cinfo, TRUE);
@@ -358,12 +377,10 @@ jpeg_each3(VALUE _args)
     intrp.cmp = dinfo->output_components;
     intrp.read = jpeg_read;
     intrp.write = jpeg_write;
-    data[0] = dinfo;
-    data[1] = cinfo;
-    intrp.data = (void *)data;
+    intrp.read_data = dinfo;
+    intrp.write_data = cinfo;
 
     bilinear(&intrp);
-    //nearest(&intrp);
 
     jpeg_abort_decompress(dinfo);
     jpeg_finish_compress(cinfo);
@@ -485,6 +502,71 @@ jpeg_each(VALUE self)
     return self;
 }
 
+static void
+png_normalize_input(png_structp read_ptr, png_infop read_i_ptr)
+{
+    png_byte ctype;
+    int bit_depth;
+
+    bit_depth = png_get_bit_depth(read_ptr, read_i_ptr);
+    ctype = png_get_color_type(read_ptr, read_i_ptr);
+
+    if (ctype == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
+      png_set_gray_1_2_4_to_8(read_ptr);
+
+    if (bit_depth < 8)
+       png_set_packing(read_ptr);
+    else if (bit_depth == 16)
+#if PNG_LIBPNG_VER >= 10504
+	png_set_scale_16(read_ptr);
+#else
+	png_set_strip_16(read_ptr);
+#endif
+
+    if (png_get_valid(read_ptr, read_i_ptr, PNG_INFO_tRNS))
+	png_set_tRNS_to_alpha(read_ptr);
+    
+    if (ctype == PNG_COLOR_TYPE_PALETTE)
+        png_set_palette_to_rgb(read_ptr);
+
+    png_read_update_info(read_ptr, read_i_ptr);
+}
+
+static VALUE
+png_interlaced2(VALUE arg)
+{
+    bilinear((struct interpolation *)arg);
+}
+
+static void
+png_interlaced(png_structp rpng, struct interpolation *intrp)
+{
+    struct bitmap b;
+    png_bytep *rows;
+    char *data;
+    int i, state;
+
+    b.rowlen = intrp->sw * intrp->cmp;
+    data = malloc(b.rowlen * intrp->sh);
+    b.cur = data;
+
+    rows = malloc(intrp->sh * sizeof(png_bytep));
+    for (i=0; i<intrp->sh; i++)
+	rows[i] = data + (i * b.rowlen);
+
+    png_read_image(rpng, rows);
+
+    intrp->read = bitmap_read;
+    intrp->read_data = (void *)&b;
+
+    rb_protect(png_interlaced2, (VALUE)intrp, &state);
+
+    free(rows);
+    free(data);
+
+    if (state) rb_jump_tag(state);
+}
+
 static VALUE
 png_each2(VALUE _args)
 {
@@ -494,33 +576,48 @@ png_each2(VALUE _args)
     png_structp read_ptr=(png_structp)args[2];
     png_infop read_i_ptr=(png_infop)args[3];
     struct thumbdata *thumb=(struct thumbdata *)args[4];
-    void *data[4];
     struct interpolation intrp;
+    png_byte ctype;
 
     png_read_info(read_ptr, read_i_ptr);
+    png_normalize_input(read_ptr, read_i_ptr);
+    ctype = png_get_color_type(read_ptr, read_i_ptr);
+    
+    intrp.sw = png_get_image_width(read_ptr, read_i_ptr);
+    intrp.sh = png_get_image_height(read_ptr, read_i_ptr);
+    fix_ratio(intrp.sw, intrp.sh, &thumb->width, &thumb->height);
     png_set_IHDR(write_ptr, write_i_ptr, thumb->width, thumb->height, 8,
-		 PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
-		 PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+		 ctype, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT,
+		 PNG_FILTER_TYPE_DEFAULT);
     png_write_info(write_ptr, write_i_ptr);
 
-    intrp.sw = png_get_image_width(read_ptr, read_i_ptr);
-    intrp.sh = png_get_image_height(read_ptr, read_i_ptr);
+    switch (ctype) {
+      case PNG_COLOR_TYPE_GRAY: intrp.cmp = 1; break;
+      case PNG_COLOR_TYPE_GRAY_ALPHA: intrp.cmp = 2; break;
+      case PNG_COLOR_TYPE_RGB: intrp.cmp = 3; break;
+      case PNG_COLOR_TYPE_RGB_ALPHA: intrp.cmp = 4; break;
+      default: rb_raise(rb_eRuntimeError, "png color type not supported.");
+    }
+
     intrp.dw = thumb->width;
     intrp.dh = thumb->height;
-    intrp.cmp = 3;
-    intrp.read = png_read;
     intrp.write = png_write;
-    data[0] = write_ptr;
-    data[1] = write_i_ptr;
-    data[2] = read_ptr;
-    data[3] = read_i_ptr;
-    intrp.data = (void *)data;
-
-    bilinear(&intrp);
+    intrp.write_data = write_ptr;
     
-    png_read_end(read_ptr, (png_infop)NULL);
+    switch (png_get_interlace_type(read_ptr, read_i_ptr)) {
+      case PNG_INTERLACE_NONE:
+	intrp.read = png_read;
+	intrp.read_data = read_ptr;
+	bilinear(&intrp);
+	break;
+      case PNG_INTERLACE_ADAM7:
+	png_interlaced(read_ptr, &intrp);
+	break;
+      default: rb_raise(rb_eRuntimeError, "png interlace type not supported.");
+    }
+
     png_write_end(write_ptr, write_i_ptr);
-    
+
     return Qnil;
 }
 
@@ -543,17 +640,17 @@ png_each(VALUE self)
     Data_Get_Struct(self, struct thumbdata, thumb);
 
     write_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL,
-				      (png_error_ptr)png_error_fn,
-				      (png_error_ptr)png_warning_fn);
+					(png_error_ptr)png_error_fn,
+					(png_error_ptr)png_warning_fn);
     write_i_ptr = png_create_info_struct(write_ptr);
     png_set_write_fn(write_ptr, NULL, png_write_data, png_flush_data);
 
     src.io = thumb->io;
-    src.buffer = rb_str_new(0, 0);    
+    src.buffer = rb_str_new(0, 0);
 
     read_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL,
-				     (png_error_ptr)png_error_fn,
-				     (png_error_ptr)png_warning_fn);
+				      (png_error_ptr)png_error_fn,
+				      (png_error_ptr)png_warning_fn);
     read_i_ptr = png_create_info_struct(read_ptr);
     png_set_read_fn(read_ptr, (void *)&src, png_read_data);
 
@@ -572,7 +669,7 @@ png_each(VALUE self)
 }
 
 void
-Init_oil()
+Init_oil(void)
 {
     VALUE mOil = rb_define_module("Oil");
 

data/test/helper.rb

@@ -0,0 +1,12 @@
+class CustomError < RuntimeError; end
+
+class CustomIO
+  def initialize(proc, *args)
+    @parent = StringIO.new(*args)
+    @proc = proc
+  end
+
+  def read(size, buf=nil)
+    @proc.call(@parent, size, buf) if @proc
+  end
+end

data/test/test_jpeg.rb

@@ -2,6 +2,7 @@ require 'rubygems'
 require 'minitest/autorun'
 require 'oil'
 require 'stringio'
+require 'helper'
 
 module Oil
   class TestJPEG < MiniTest::Unit::TestCase
@@ -63,8 +64,14 @@ module Oil
     
     def test_io_returns_too_much_data
       proc = Proc.new do |io, size, buf|
-        buf.slice!(0,0)
-        buf << (io.read(size)[0..-2] * 2)
+        str = io.read(size)
+        str = str[0..-2] * 2 if str
+        if buf
+          buf.slice!(0,0) # this empties the buffer
+          buf << str
+        else
+          str
+        end
       end
       assert_raises(RuntimeError) { custom_io proc, JPEG_DATA }
     end
@@ -88,7 +95,11 @@ module Oil
       proc = Proc.new do |parent, size, buf|
         raise CustomError if flag
         flag = true
-        parent.read(size, buf)
+        if buf
+          parent.read(size, buf)
+        else
+          parent.read(size)
+        end
       end
       assert_raises(CustomError) { custom_io proc, big_jpeg }
     end
@@ -98,25 +109,44 @@ module Oil
       proc = Proc.new do |parent, size, buf|
         throw :foo if flag
         flag = true
-        parent.read(size, buf)
+        if buf
+          parent.read(size, buf)
+        else
+          parent.read(size)
+        end
       end
       catch(:foo){ custom_io proc, big_jpeg }
     end
 
     def test_io_shrinks_buffer
       proc = Proc.new do |parent, size, buf|
-        parent.read(size, buf)
-        buf.slice!(0, 10)
+        if buf
+          parent.read(size, buf)
+          buf.slice!(0, 10)
+        else
+          res = parent.read(size)
+          res[10, -1]
+        end
       end
       assert_raises(RuntimeError) { custom_io(proc, big_jpeg) }
     end
 
-    def test_io_enlarges_buffer
+    def test_io_enlarges_buffer_with_eof
       proc = Proc.new do |parent, size, buf|
-        res = parent.read(size, buf)
-        buf << res
+        if buf
+          parent.read(size, buf)
+          buf << buf
+        else
+          str = parent.read(size)
+          str * 2
+        end
+      end
+      
+      if(RUBY_PLATFORM =~ /java/)
+        assert_raises(RuntimeError) { custom_io(proc, big_jpeg) }
+      else
+        validate_jpeg custom_io(proc, big_jpeg) # libjpeg stops when reaches eof
       end
-      validate_jpeg custom_io(proc, big_jpeg) # how is this okay?
     end
 
     def test_io_seek
@@ -187,18 +217,4 @@ module Oil
       io
     end
   end
-
-  class CustomError < RuntimeError; end
-
-  class CustomIO
-    def initialize(proc, *args)
-      @parent = StringIO.new(*args)
-      @proc = proc
-    end
-
-    def read(size, buf)
-      @proc.call(@parent, size, buf) if @proc
-    end
-  end
 end
-

data/test/test_png.rb

@@ -2,6 +2,7 @@ require 'rubygems'
 require 'minitest/autorun'
 require 'oil'
 require 'stringio'
+require 'helper'
 
 module Oil
   class TestPNG < MiniTest::Unit::TestCase
@@ -31,7 +32,7 @@ module Oil
     def test_bogus_end_chunk
       str = PNG_DATA.dup
       str[-6] = "\x10"
-      assert_raises(RuntimeError) { resize_string(str) }      
+      validate_png resize_string(str)
     end
 
     def test_calls_each_during_yield
@@ -61,8 +62,14 @@ module Oil
     
     def test_io_returns_too_much_data
       proc = Proc.new do |io, size, buf|
-        buf.slice!(0,0)
-        buf << (io.read(size)[0..-2] * 2)
+        str = io.read(size)
+        str = str[0..-2] * 2 if str
+        if buf
+          buf.slice!(0,0) # this empties the buffer
+          buf << str
+        else
+          str
+        end
       end
       assert_raises(RuntimeError) { custom_io proc, PNG_DATA }
     end
@@ -86,7 +93,11 @@ module Oil
       proc = Proc.new do |parent, size, buf|
         raise CustomError if flag
         flag = true
-        parent.read(size, buf)
+        if buf
+          parent.read(size, buf)
+        else
+          parent.read(size)
+        end
       end
       assert_raises(CustomError) { custom_io proc, big_png }
     end
@@ -96,25 +107,40 @@ module Oil
       proc = Proc.new do |parent, size, buf|
         throw :foo if flag
         flag = true
-        parent.read(size, buf)
+        if buf
+          parent.read(size, buf)
+        else
+          parent.read(size)
+        end
       end
       catch(:foo){ custom_io proc, big_png }
     end
 
     def test_io_shrinks_buffer
       proc = Proc.new do |parent, size, buf|
-        parent.read(size, buf)
-        buf.slice!(0, 10)
+        if buf
+          parent.read(size, buf)
+          buf.slice!(0, 10)
+        else
+          res = parent.read(size)
+          res[10, -1]
+        end
       end
       assert_raises(RuntimeError) { custom_io(proc, big_png) }
     end
 
-    def test_io_enlarges_buffer
+    def test_io_enlarges_buffer_with_eof
       proc = Proc.new do |parent, size, buf|
-        res = parent.read(size, buf)
-        buf << res
+        if buf
+          parent.read(size, buf)
+          buf << buf
+        else
+          str = parent.read(size)
+          str * 2
+        end
       end
-      assert_raises(RuntimeError) { validate_jpeg custom_io(proc, big_png) }
+      
+      assert_raises(RuntimeError) { custom_io(proc, big_png) }
     end
 
     # Test yielding
@@ -180,18 +206,4 @@ module Oil
       io
     end
   end
-
-  class CustomError < RuntimeError; end
-
-  class CustomIO
-    def initialize(proc, *args)
-      @parent = StringIO.new(*args)
-      @proc = proc
-    end
-
-    def read(size, buf)
-      @proc.call(@parent, size, buf) if @proc
-    end
-  end
 end
-

metadata

@@ -1,54 +1,63 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: oil
-version: !ruby/object:Gem::Version
-  version: 0.0.2
+version: !ruby/object:Gem::Version 
   prerelease: 
+  version: 0.0.3
 platform: ruby
-authors:
-- Timothy Elliott
+authors: 
+  - Timothy Elliott
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-08 00:00:00.000000000 Z
+
+date: 2012-03-28 00:00:00 Z
 dependencies: []
-description: 
+
+description: Oil resizes JPEG and PNG images. It aims for fast performance and low memory use.
 email: tle@holymonkey.com
 executables: []
-extensions:
-- ext/extconf.rb
-extra_rdoc_files:
-- README.rdoc
-files:
-- Rakefile
-- README.rdoc
-- ext/oil.c
-- ext/extconf.rb
-- test/test_jpeg.rb
-- test/test_png.rb
+
+extensions: 
+  - ext/extconf.rb
+extra_rdoc_files: 
+  - README.rdoc
+files: 
+  - Rakefile
+  - README.rdoc
+  - ext/oil.c
+  - ext/extconf.rb
+  - ext/oil.jar
+  - test/helper.rb
+  - test/test_jpeg.rb
+  - test/test_png.rb
 homepage: http://github.com/ender672/oil
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
-- ext
-required_ruby_version: !ruby/object:Gem::Requirement
+
+require_paths: 
+  - ext
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 1.8.17
+rubygems_version: 1.8.21
 signing_key: 
 specification_version: 3
 summary: Oil resizes JPEG and PNG images.
-test_files:
-- test/test_jpeg.rb
-- test/test_png.rb
+test_files: 
+  - test/helper.rb
+  - test/test_jpeg.rb
+  - test/test_png.rb