gd2-ffij 0.0.2 → 0.0.3

data/Rakefile

@@ -10,7 +10,7 @@ begin
 	require 'jeweler'
 	Jeweler::Tasks.new do |gem|
 		gem.name        = "gd2-ffij"
-		gem.version     = "0.0.2"
+		gem.version     = "0.0.3"
 		gem.summary     = "gd2-ffij is a refactoring of the Ruby/GD2 library implemented with FFI"
 		gem.description = "gd2-ffij is a refactoring of the Ruby/GD2 library implemented with FFI"
 		gem.email       = "dark.panda@gmail.com"

data/gd2-ffij.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{gd2-ffij}
-  s.version = "0.0.2"
+  s.version = "0.0.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["J Smith"]
-  s.date = %q{2010-03-13}
+  s.date = %q{2010-11-11}
   s.description = %q{gd2-ffij is a refactoring of the Ruby/GD2 library implemented with FFI}
   s.email = %q{dark.panda@gmail.com}
   s.extra_rdoc_files = [
@@ -75,7 +75,7 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/dark-panda/gd2-ffij}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.6}
+  s.rubygems_version = %q{1.3.7}
   s.summary = %q{gd2-ffij is a refactoring of the Ruby/GD2 library implemented with FFI}
   s.test_files = [
     "test/canvas_test.rb",
@@ -87,7 +87,7 @@ Gem::Specification.new do |s|
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
     else
     end
   else

data/lib/gd2-ffij.rb

@@ -24,17 +24,23 @@ require 'ffi'
 require 'rbconfig'
 
 module GD2
-  VERSION = '0.0.1'.freeze
+  VERSION = '0.0.3'.freeze
 
   module GD2FFI
     def self.gd_library_name
-      case Config::CONFIG['arch']
-      when /darwin/
-        'libgd.2.dylib'
-      when /mswin32/, /cygwin/
-        'bgd.dll'
+      if ENV['GD2_LIBRARY_PATH']
+        ENV['GD2_LIBRARY_PATH']
       else
-        'libgd.so.2'
+        lib = case Config::CONFIG['arch']
+        when /darwin/
+          [ '/usr/lib', '/usr/local/lib', '/opt/local/lib' ].detect { |path|
+            File.exists?("#{path}/libgd.2.dylib")
+          }.to_s + '/libgd.2.dylib'
+        when /mswin32/, /cygwin/
+          'bgd.dll'
+        else
+          'libgd.so.2'
+        end
       end
     end
 

data/lib/gd2/canvas.rb

@@ -59,7 +59,7 @@ module GD2
 
       def draw(image, mode)
         GD2FFI.send(:gdImageLine, image.image_ptr,
-          @p1.x, @p1.y, @p2.x, @p2.y, mode)
+          @p1.x.to_i, @p1.y.to_i, @p2.x.to_i, @p2.y.to_i, mode.to_i)
         nil
       end
     end
@@ -70,7 +70,7 @@ module GD2
       end
 
       def draw(image, mode)
-        GD2FFI.send(draw_sym, image.image_ptr, @p1.x, @p1.y, @p2.x, @p2.y, mode)
+        GD2FFI.send(draw_sym, image.image_ptr, @p1.x.to_i, @p1.y.to_i, @p2.x.to_i, @p2.y.to_i, mode.to_i)
         nil
       end
 
@@ -93,7 +93,7 @@ module GD2
       def draw(image, mode)
         GD2FFI.send(draw_sym, image.image_ptr, @points.map { |point|
           point.coordinates.pack('i_i_')
-        }.join(''), @points.length, mode)
+        }.join(''), @points.length, mode.to_i)
         nil
       end
 
@@ -122,9 +122,9 @@ module GD2
       end
 
       def draw(image, mode)
-        GD2FFI.send(:gdImageArc, image.image_ptr, @center.x, @center.y,
-          @width, @height,
-          @range.begin.to_degrees.round, @range.end.to_degrees.round, mode)
+        GD2FFI.send(:gdImageArc, image.image_ptr, @center.x.to_i, @center.y.to_i,
+          @width.to_i, @height.to_i,
+          @range.begin.to_degrees.round.to_i, @range.end.to_degrees.round.to_i, mode.to_i)
         nil
       end
     end
@@ -144,10 +144,10 @@ module GD2
       end
 
       def draw(image, mode)
-        GD2FFI.send(:gdImageFilledArc, image.image_ptr, @center.x, @center.y,
-          @width, @height,
-          @range.begin.to_degrees.round, @range.end.to_degrees.round,
-          mode, style)
+        GD2FFI.send(:gdImageFilledArc, image.image_ptr, @center.x.to_i, @center.y.to_i,
+          @width.to_i, @height.to_i,
+          @range.begin.to_degrees.round.to_i, @range.end.to_degrees.round.to_i,
+          mode.to_i, style.to_i)
         nil
       end
 
@@ -168,16 +168,16 @@ module GD2
       end
 
       def draw(image, mode)
-        GD2FFI.send(:gdImageArc, image.image_ptr, @center.x, @center.y,
-          @width, @height, 0, 360, mode)
+        GD2FFI.send(:gdImageArc, image.image_ptr, @center.x.to_i, @center.y.to_i,
+          @width.to_i, @height.to_i, 0, 360, mode.to_i)
         nil
       end
     end
 
     class FilledEllipse < Ellipse
       def draw(image, mode)
-        GD2FFI.send(:gdImageFilledEllipse, image.image_ptr, @center.x, @center.y,
-          @width, @height, mode)
+        GD2FFI.send(:gdImageFilledEllipse, image.image_ptr, @center.x.to_i, @center.y.to_i,
+          @width.to_i, @height.to_i, mode.to_i)
       end
     end
 
@@ -240,7 +240,7 @@ module GD2
     end
 
     def thickness=(thickness)
-      GD2FFI.send(:gdImageSetThickness, @image.image_ptr, @thickness = thickness)
+      GD2FFI.send(:gdImageSetThickness, @image.image_ptr, @thickness = thickness.to_i)
     end
 
     def style=(ary)
@@ -331,14 +331,14 @@ module GD2
     end
 
     def fill
-      GD2FFI.send(:gdImageFill, @image.image_ptr, @point.x, @point.y, fill_pixel)
+      GD2FFI.send(:gdImageFill, @image.image_ptr, @point.x.to_i, @point.y.to_i, fill_pixel.to_i)
       self
     end
 
     def fill_to(border)
       # An apparent bug in gd prevents us from using fill_pixel
-      GD2FFI.send(:gdImageFillToBorder, @image.image_ptr, @point.x, @point.y,
-        @image.color2pixel(border), pixel)
+      GD2FFI.send(:gdImageFillToBorder, @image.image_ptr, @point.x.to_i, @point.y.to_i,
+        @image.color2pixel(border), pixel.to_i)
       self
     end
 
@@ -405,9 +405,9 @@ module GD2
       elsif anti_aliasing?
         if @dont_blend
           GD2FFI.send(:gdImageSetAntiAliasedDontBlend, @image.image_ptr,
-            pixel, @dont_blend)
+            pixel.to_i, @dont_blend.to_i)
         else
-          GD2FFI.send(:gdImageSetAntiAliased, @image.image_ptr, pixel)
+          GD2FFI.send(:gdImageSetAntiAliased, @image.image_ptr, pixel.to_i)
         end
         ANTI_ALIASED
       else

data/lib/gd2/color.rb

@@ -215,7 +215,7 @@ module GD2
     # Alpha blend this color with the given color. If this color is associated
     # with a palette entry, this also modifies the palette.
     def alpha_blend!(other)
-      self.rgba = GD2FFI.send(:gdAlphaBlend, rgba, other.rgba)
+      self.rgba = GD2FFI.send(:gdAlphaBlend, rgba.to_i, other.rgba.to_i)
       self
     end
     alias << alpha_blend!

data/lib/gd2/font.rb

@@ -58,7 +58,7 @@ module GD2
         angle == 0.degrees || angle == 90.degrees
 
       GD2FFI.send(angle > 0 ? :gdImageStringUp : :gdImageString, image_ptr,
-        font_ptr, x, y, string, fg)
+        font_ptr, x.to_i, y.to_i, string, fg.to_i)
       nil
     end
   end
@@ -114,19 +114,17 @@ module GD2
     @@fontconfig = false
 
     def self.register(font)   #:nodoc:
-      Thread.critical = true
+      Thread.exclusive do
+        count = @@fontcount
+        @@fontcount += 1
 
-      count = @@fontcount
-      @@fontcount += 1
+        if count.zero?
+          raise FreeTypeError, 'FreeType library failed to initialize' unless
+            GD2FFI.send(:gdFontCacheSetup).zero?
+        end
 
-      if count.zero?
-        raise FreeTypeError, 'FreeType library failed to initialize' unless
-          GD2FFI.send(:gdFontCacheSetup).zero?
+        ObjectSpace.define_finalizer(font, font_finalizer)
       end
-
-      ObjectSpace.define_finalizer(font, font_finalizer)
-    ensure
-      Thread.critical = false
     end
 
     def self.font_finalizer
@@ -134,12 +132,10 @@ module GD2
     end
 
     def self.unregister
-      Thread.critical = true
-
-      @@fontcount -= 1
-      GD2FFI.send(:gdFontCacheShutdown) if @@fontcount.zero?
-    ensure
-      Thread.critical = false
+      Thread.exclusive do
+        @@fontcount -= 1
+        GD2FFI.send(:gdFontCacheShutdown) if @@fontcount.zero?
+      end
     end
 
     private_class_method :font_finalizer, :unregister
@@ -253,7 +249,7 @@ module GD2
     def draw(image_ptr, x, y, angle, string, fg)  #:nodoc:
       brect = FFI::MemoryPointer.new(:int, 8)
       strex = strex(true)
-      args = [ image_ptr, brect, fg, @fontname, @ptsize, angle.to_f, x, y, string.gsub('&', '&'), strex ]
+      args = [ image_ptr, brect, fg, @fontname, @ptsize, angle.to_f, x.to_i, y.to_i, string.gsub('&', '&'), strex ]
 
       r = GD2FFI.send(:gdImageStringFTEx, *args)
       raise FreeTypeError.new(r.read_string) unless r.null?
@@ -290,9 +286,9 @@ module GD2
       top, bottom, fgcolor
     ) #:nodoc:
       r = GD2FFI.send(
-        :gdImageStringFTCircle, image_ptr, cx, cy,
+        :gdImageStringFTCircle, image_ptr, cx.to_i, cy.to_i,
         radius.to_f, text_radius.to_f, fill_portion.to_f, @fontname, @ptsize,
-        top || '', bottom || '', fgcolor
+        top || '', bottom || '', fgcolor.to_i
       )
       raise FreeTypeError.new(r.read_string) unless r.null?
       nil

data/lib/gd2/image.rb

@@ -88,12 +88,14 @@ module GD2
     # automatically (JPEG, PNG, GIF, WBMP, or GD2). The resulting image will be
     # either of class Image::TrueColor or Image::IndexedColor.
     def self.load(src)
+      src = src.force_encoding("BINARY") if src.respond_to? :force_encoding
       case src
       when File
         pos = src.pos
         magic = src.read(4)
         src.pos = pos
         data = src.read
+        data = data.force_encoding("BINARY") if data.respond_to? :force_encoding
         args = [ data.length, data ]
       when String
         magic = src
@@ -124,16 +126,23 @@ module GD2
     end
 
     def self.data_type(str)
-      case str
-      when /\A\xff\xd8/
+      ct = 0
+      mgc = ""
+      str.each_byte do |byte|
+        break if ct == 4
+        mgc << byte.to_s
+        ct += 1
+      end
+      case mgc
+      when "255216255224"
         :jpeg
-      when /\A\x89PNG/
+      when "137807871"
         :png
-      when /\AGIF8/
+      when "71737056"
         :gif
-      when /\A\x00/
+      when "001300"
         :wbmp
-      when /\Agd2/
+      when "103100500"
         :gd2
       end
     end
@@ -173,7 +182,7 @@ module GD2
         raise ArgumentError, 'Missing required option :height' if height.nil?
         # TODO:
         ptr = File.open(filename, 'rb') do |file|
-          GD2FFI.send(:gdImageCreateFromGd2Part, file, x, y, width, height)
+          GD2FFI.send(:gdImageCreateFromGd2Part, file, x.to_i, y.to_i, width.to_i, height.to_i)
         end
       else
         raise ArgumentError, "Unexpected options #{options.inspect}" unless
@@ -191,6 +200,7 @@ module GD2
           'Format (or file extension) is not recognized' unless create_sym
 
         file = File.read(filename)
+        file = file.force_encoding("BINARY") if file.respond_to? :force_encoding
         file_ptr = FFI::MemoryPointer.new(file.size, 1, false)
         file_ptr.put_bytes(0, file)
 
@@ -212,7 +222,7 @@ module GD2
     private_class_method :image_true_color?
 
     def self.create_image_ptr(sx, sy, alpha_blending = true)  #:nodoc:
-      ptr = FFIStruct::ImagePtr.new(GD2FFI.send(create_image_sym, sx, sy))
+      ptr = FFIStruct::ImagePtr.new(GD2FFI.send(create_image_sym, sx.to_i, sy.to_i))
       GD2FFI.send(:gdImageAlphaBlending, ptr, alpha_blending ? 1 : 0)
       ptr
     end
@@ -287,13 +297,13 @@ module GD2
 
     # Return the pixel value at image location (+x+, +y+).
     def get_pixel(x, y)
-      GD2FFI.send(:gdImageGetPixel, @image_ptr, x, y)
+      GD2FFI.send(:gdImageGetPixel, @image_ptr, x.to_i, y.to_i)
     end
     alias pixel get_pixel
 
     # Set the pixel value at image location (+x+, +y+).
     def set_pixel(x, y, value)
-      GD2FFI.send(:gdImageSetPixel, @image_ptr, x, y, value)
+      GD2FFI.send(:gdImageSetPixel, @image_ptr, x.to_i, y.to_i, value.to_i)
       nil
     end
 
@@ -400,7 +410,7 @@ module GD2
       clip = clipping
       begin
         p clipping
-        GD2FFI.send(:gdImageSetClip, image_ptr, x1, y1, x2, y2)
+        GD2FFI.send(:gdImageSetClip, image_ptr, x1.to_i, y1.to_i, x2.to_i, y2.to_i)
         p clipping
         yield self
         self
@@ -411,7 +421,7 @@ module GD2
 
     # Return *true* if the current clipping rectangle excludes the given point.
     def clips?(x, y)
-      GD2FFI.send(:gdImageBoundsSafe, image_ptr, x, y).zero?
+      GD2FFI.send(:gdImageBoundsSafe, image_ptr, x.to_i, y.to_i).zero?
     end
 
     # Provide a drawing environment for a block. See GD2::Canvas.
@@ -496,7 +506,7 @@ module GD2
     # compression (0 = none, 1 = minimal but fast, 9 = best but slow).
     def png(level = nil)
       size = FFI::MemoryPointer.new(:pointer)
-      ptr = GD2FFI.send(:gdImagePngPtrEx, image_ptr, size, level || -1)
+      ptr = GD2FFI.send(:gdImagePngPtrEx, image_ptr, size, level.to_i || -1)
       ptr.get_bytes(0, size.get_int(0))
     ensure
       GD2FFI.send(:gdFree, ptr)
@@ -541,7 +551,7 @@ module GD2
     # The specified +fmt+ may be either GD2::FMT_RAW or GD2::FMT_COMPRESSED.
     def gd2(fmt = FMT_COMPRESSED, chunk_size = 0)
       size = FFI::MemoryPointer.new(:pointer)
-      ptr = GD2FFI.send(:gdImageGd2Ptr, image_ptr, chunk_size, fmt, size)
+      ptr = GD2FFI.send(:gdImageGd2Ptr, image_ptr, chunk_size.to_i, fmt.to_i, size)
       ptr.get_bytes(0, size.get_int(0))
     ensure
       GD2FFI.send(:gdFree, ptr)
@@ -555,10 +565,10 @@ module GD2
       raise ArgumentError unless src_w.nil? == src_h.nil?
       if src_w
         GD2FFI.send(:gdImageCopyResampled, image_ptr, other.image_ptr,
-          dst_x, dst_y, src_x, src_y, dst_w, dst_h, src_w, src_h)
+          dst_x.to_i, dst_y.to_i, src_x.to_i, src_y.to_i, dst_w.to_i, dst_h.to_i, src_w.to_i, src_h.to_i)
       else
         GD2FFI.send(:gdImageCopy, image_ptr, other.image_ptr,
-          dst_x, dst_y, src_x, src_y, dst_w, dst_h)
+          dst_x.to_i, dst_y.to_i, src_x.to_i, src_y.to_i, dst_w.to_i, dst_h.to_i)
       end
       self
     end
@@ -569,7 +579,7 @@ module GD2
     # may be floating point.
     def copy_from_rotated(other, dst_x, dst_y, src_x, src_y, w, h, angle)
       GD2FFI.send(:gdImageCopyRotated, image_ptr, other.image_ptr,
-        dst_x.to_f, dst_y.to_f, src_x, src_y, w, h, angle.to_degrees.round)
+        dst_x.to_f, dst_y.to_f, src_x.to_i, src_y.to_i, w.to_i, h.to_i, angle.to_degrees.round.to_i)
       self
     end
 
@@ -579,7 +589,7 @@ module GD2
     # channel information from the source image is ignored.
     def merge_from(other, dst_x, dst_y, src_x, src_y, w, h, pct)
       GD2FFI.send(:gdImageCopyMerge, image_ptr, other.image_ptr,
-        dst_x, dst_y, src_x, src_y, w, h, pct.to_percent.round)
+        dst_x.to_i, dst_y.to_i, src_x.to_i, src_y.to_i, w.to_i, h.to_i, pct.to_percent.round.to_i)
       self
     end
 
@@ -588,7 +598,7 @@ module GD2
     def rotate!(angle, axis_x = width / 2.0, axis_y = height / 2.0)
       ptr = self.class.create_image_ptr(width, height, alpha_blending?)
       GD2FFI.send(:gdImageCopyRotated, ptr, image_ptr,
-        axis_x.to_f, axis_y.to_f, 0, 0, width, height, angle.to_degrees.round)
+        axis_x.to_f, axis_y.to_f, 0, 0, width.to_i, height.to_i, angle.to_degrees.round.to_i)
       init_with_image(ptr)
     end
 
@@ -601,7 +611,7 @@ module GD2
     # (0, 0).
     def crop!(x, y, w, h)
       ptr = self.class.create_image_ptr(w, h, alpha_blending?)
-      GD2FFI.send(:gdImageCopy, ptr, image_ptr, 0, 0, x, y, w, h)
+      GD2FFI.send(:gdImageCopy, ptr, image_ptr, 0, 0, x.to_i, y.to_i, w.to_i, h.to_i)
       init_with_image(ptr)
     end
 
@@ -615,7 +625,7 @@ module GD2
     def uncrop!(x1, y1 = x1, x2 = x1, y2 = y1)
       ptr = self.class.create_image_ptr(x1 + width + x2, y1 + height + y2,
         alpha_blending?)
-      GD2FFI.send(:gdImageCopy, ptr, image_ptr, x1, y1, 0, 0, width, height)
+      GD2FFI.send(:gdImageCopy, ptr, image_ptr, x1.to_i, y1.to_i, 0, 0, width.to_i, height.to_i)
       init_with_image(ptr)
     end
 
@@ -630,7 +640,7 @@ module GD2
     def resize!(w, h, resample = true)
       ptr = self.class.create_image_ptr(w, h, false)
       GD2FFI.send(resample ? :gdImageCopyResampled : :gdImageCopyResized,
-        ptr, image_ptr, 0, 0, 0, 0, w, h, width, height)
+        ptr, image_ptr, 0, 0, 0, 0, w.to_i, h.to_i, width.to_i, height.to_i)
       alpha_blending = alpha_blending?
       init_with_image(ptr)
       self.alpha_blending = alpha_blending
@@ -648,7 +658,7 @@ module GD2
     # Note that the original image must be square.
     def polar_transform!(radius)
       raise 'Image must be square' unless width == height
-      ptr = GD2FFI.send(:gdImageSquareToCircle, image_ptr, radius)
+      ptr = GD2FFI.send(:gdImageSquareToCircle, image_ptr, radius.to_i)
       raise LibraryError unless ptr
       init_with_image(ptr)
     end
@@ -675,7 +685,7 @@ module GD2
     # +dither+ controls whether dithering is used.
     def to_indexed_color(colors = MAX_COLORS, dither = true)
       ptr = GD2FFI.send(:gdImageCreatePaletteFromTrueColor,
-        to_true_color.image_ptr, dither ? 1 : 0, colors)
+        to_true_color.image_ptr, dither ? 1 : 0, colors.to_i)
       raise LibraryError unless ptr
 
       obj = IndexedColor.allocate.init_with_image(ptr)
@@ -757,7 +767,7 @@ module GD2
     def merge_from(other, dst_x, dst_y, src_x, src_y, w, h, pct, gray = false)
       return super(other, dst_x, dst_y, src_x, src_y, w, h, pct) unless gray
       GD2FFI.send(:gdImageCopyMergeGray, image_ptr, other.image_ptr,
-        dst_x, dst_y, src_x, src_y, w, h, pct.to_percent.round)
+        dst_x.to_i, dst_y.to_i, src_x.to_i, src_y.to_i, w.to_i, h.to_i, pct.to_percent.round.to_i)
       self
     end
   end
@@ -778,7 +788,7 @@ module GD2
     end
 
     def sharpen(pct)  #:nodoc:
-      GD2FFI.send(:gdImageSharpen, image_ptr, pct.to_percent.round)
+      GD2FFI.send(:gdImageSharpen, image_ptr, pct.to_percent.round.to_i)
       self
     end
   end

data/lib/gd2/palette.rb

@@ -104,7 +104,7 @@ module GD2
     def resolve(color)
       raise TypeError unless color.kind_of? Color
       c = GD2FFI.send(:gdImageColorResolveAlpha, @image.image_ptr,
-        color.red, color. green, color.blue, color.alpha)
+        color.red.to_i, color.green.to_i, color.blue.to_i, color.alpha.to_i)
       c == -1 ? nil : get_color(c)
     end
 
@@ -113,7 +113,7 @@ module GD2
     def exact(color)
       raise TypeError unless color.kind_of? Color
       c = GD2FFI.send(:gdImageColorExactAlpha, @image.image_ptr,
-        color.red, color.green, color.blue, color.alpha)
+        color.red.to_i, color.green.to_i, color.blue.to_i, color.alpha.to_i)
       c == -1 ? nil : get_color(c)
     end
 
@@ -129,7 +129,7 @@ module GD2
     def closest(color)
       raise TypeError unless color.kind_of? Color
       c = GD2FFI.send(:gdImageColorClosestAlpha, @image.image_ptr,
-        color.red, color.green, color.blue, color.alpha)
+        color.red.to_i, color.green.to_i, color.blue.to_i, color.alpha.to_i)
       c == -1 ? nil : get_color(c)
     end
 
@@ -138,7 +138,7 @@ module GD2
     def closest_hwb(color)
       raise TypeError unless color.kind_of? Color
       c = GD2FFI.send(:gdImageColorClosestHWB, @image.image_ptr,
-        color.red, color.green, color.blue)
+        color.red.to_i, color.green.to_i, color.blue.to_i)
       c == -1 ? nil : get_color(c)
     end
 
@@ -148,7 +148,7 @@ module GD2
     def allocate(color)
       raise TypeError unless color.kind_of? Color
       c = GD2FFI.send(:gdImageColorAllocateAlpha, @image.image_ptr,
-        color.red, color.green, color.blue, color.alpha)
+        color.red.to_i, color.green.to_i, color.blue.to_i, color.alpha.to_i)
       c == -1 ? raise(Palette::PaletteFullError, 'Palette is full') :
         get_color(c)
     end
@@ -164,7 +164,7 @@ module GD2
     def deallocate(color)
       color = exact(color) unless color.index
       return nil if color.nil? || color.index.nil?
-      GD2FFI.send(:gdImageColorDeallocate, @image.image_ptr, color.index)
+      GD2FFI.send(:gdImageColorDeallocate, @image.image_ptr, color.index.to_i)
       nil
     end
 

data/test/canvas_test.rb

@@ -4,183 +4,183 @@ require 'tmpdir'
 require 'rubygems'
 require 'gd2-ffij'
 
-require 'test/test_helper'
+require './test/test_helper'
 
 class CanvasTest < Test::Unit::TestCase
-  include TestHelper
-
-  def test_line
-    image = new_image
-    image.draw do |pen|
-      pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
-      pen.line(64, 64, 192, 192)
-    end
-    assert(image == load_image('test_canvas_line.gd2'))
-  end
-
-  def test_rectangle
-    image = new_image
-    image.draw do |pen|
-      pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
-      pen.rectangle(64, 64, 192, 192)
-    end
-    assert(image == load_image('test_canvas_rectangle.gd2'))
-  end
-
-  def test_filled_rectangle
-    image = new_image
-    image.draw do |pen|
-      pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
-      pen.rectangle(64, 64, 192, 192, true)
-    end
-    assert(image == load_image('test_canvas_filled_rectangle.gd2'))
-  end
-
-  def test_polygon
-    image = new_image
-    image.draw do |pen|
-      pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
-      pen.polygon([
-        [ 64, 64 ],
-        [ 192, 192 ],
-        [ 64, 128 ]
-      ])
-    end
-    assert(image == load_image('test_canvas_polygon.gd2'))
-  end
-
-  def test_filled_polygon
-    image = new_image
-    image.draw do |pen|
-      pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
-      pen.polygon([
-        [ 64, 64 ],
-        [ 192, 192 ],
-        [ 64, 128 ]
-      ], true)
-    end
-    assert(image == load_image('test_canvas_filled_polygon.gd2'))
-  end
-
-  def test_move_to_and_line_to
-    image = new_image
-    image.draw do |pen|
-      pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
-      pen.move_to(64, 64)
-      pen.line_to(128, 128)
-    end
-    assert(image == load_image('test_canvas_move_to_and_line_to.gd2'))
-  end
-
-  def test_fill
-    image = new_image
-    image.draw do |pen|
-      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
-      pen.rectangle(64, 64, 192, 192)
-      pen.move_to(65, 65)
-      pen.fill
-    end
-    assert(image == load_image('test_fill.gd2'))
-  end
-
-  def test_arc
-    image = new_image
-    image.draw do |pen|
-      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
-      pen.arc(128, 128, 128, 128, 0..256)
-    end
-    assert(image == load_image('test_arc.gd2'))
-  end
-
-  def test_text
-    image = new_image
-    image.draw do |pen|
-      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
-      pen.font = GD2::Font::TrueType[PATH_TO_FONT, 32]
-      pen.move_to(0, 128)
-      pen.text("HELLO")
-      pen.move_to(256, 128)
-      pen.text("WORLD", Math::PI)
-    end
-    assert(image == load_image('test_text.gd2'))
-  end
-
-  def test_text_circle
-    image = new_image
-    image.draw do |pen|
-      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
-      pen.font = GD2::Font::TrueType[PATH_TO_FONT, 32]
-      pen.move_to(128, 128)
-      pen.text_circle('HELLO', 'WORLD', 100, 20, 1)
-    end
-    assert(image == load_image('test_text_circle.gd2'))
-  end
-
-  def test_wedge
-    image = new_image
-    image.draw do |pen|
-      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
-      pen.wedge(128, 128, 256, 256, 0..180)
-    end
-    assert(image == load_image('test_wedge.gd2'))
-  end
-
-  def test_filled_wedge
-    image = new_image
-    image.draw do |pen|
-      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
-      pen.wedge(128, 128, 256, 256, 0..180, true)
-    end
-    assert(image == load_image('test_filled_wedge.gd2'))
-  end
-
-  def test_ellipse
-    image = new_image
-    image.draw do |pen|
-      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
-      pen.ellipse(128, 128, 64, 32)
-    end
-    assert(image == load_image('test_ellipse.gd2'))
-  end
-
-  def test_filled_ellipse
-    image = new_image
-    image.draw do |pen|
-      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
-      pen.ellipse(128, 128, 64, 32, true)
-    end
-    assert(image == load_image('test_filled_ellipse.gd2'))
-  end
-
-  def test_circle
-    image = new_image
-    image.draw do |pen|
-      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
-      pen.circle(128, 128, 128)
-    end
-    assert(image == load_image('test_circle.gd2'))
-  end
-
-  def test_filled_circle
-    image = new_image
-    image.draw do |pen|
-      pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
-      pen.circle(128, 128, 128, true)
-    end
-    assert(image == load_image('test_filled_circle.gd2'))
-  end
-
-  def test_fill_to
-    image = new_image
-    image.draw do |pen|
-      blue = image.palette.resolve(GD2::Color[32, 64, 128])
-      red  = image.palette.resolve(GD2::Color[255, 0, 0])
-      pen.color = blue
-      pen.arc(128, 128, 256, 64, 0..(Math::PI))
-      pen.color = red
-      pen.move(128, 128)
-      pen.fill_to(blue)
-    end
-    assert(image == load_image('test_fill_to.gd2'))
-  end
+	include TestHelper
+
+	def test_line
+		image = new_image
+		image.draw do |pen|
+			pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
+			pen.line(64, 64, 192, 192)
+		end
+		assert(image == load_image('test_canvas_line.gd2'))
+	end
+
+	def test_rectangle
+		image = new_image
+		image.draw do |pen|
+			pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
+			pen.rectangle(64, 64, 192, 192)
+		end
+		assert(image == load_image('test_canvas_rectangle.gd2'))
+	end
+
+	def test_filled_rectangle
+		image = new_image
+		image.draw do |pen|
+			pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
+			pen.rectangle(64, 64, 192, 192, true)
+		end
+		assert(image == load_image('test_canvas_filled_rectangle.gd2'))
+	end
+
+	def test_polygon
+		image = new_image
+		image.draw do |pen|
+			pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
+			pen.polygon([
+				[ 64, 64 ],
+				[ 192, 192 ],
+				[ 64, 128 ]
+			])
+		end
+		assert(image == load_image('test_canvas_polygon.gd2'))
+	end
+
+	def test_filled_polygon
+		image = new_image
+		image.draw do |pen|
+			pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
+			pen.polygon([
+				[ 64, 64 ],
+				[ 192, 192 ],
+				[ 64, 128 ]
+			], true)
+		end
+		assert(image == load_image('test_canvas_filled_polygon.gd2'))
+	end
+
+	def test_move_to_and_line_to
+		image = new_image
+		image.draw do |pen|
+			pen.color = image.palette.resolve(GD2::Color[255, 255, 255])
+			pen.move_to(64, 64)
+			pen.line_to(128, 128)
+		end
+		assert(image == load_image('test_canvas_move_to_and_line_to.gd2'))
+	end
+
+	def test_fill
+		image = new_image
+		image.draw do |pen|
+			pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+			pen.rectangle(64, 64, 192, 192)
+			pen.move_to(65, 65)
+			pen.fill
+		end
+		assert(image == load_image('test_fill.gd2'))
+	end
+
+	def test_arc
+		image = new_image
+		image.draw do |pen|
+			pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+			pen.arc(128, 128, 128, 128, 0..256)
+		end
+		assert(image == load_image('test_arc.gd2'))
+	end
+
+	def test_text
+		image = new_image
+		image.draw do |pen|
+			pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+			pen.font = GD2::Font::TrueType[PATH_TO_FONT, 32]
+			pen.move_to(0, 128)
+			pen.text("HELLO")
+			pen.move_to(256, 128)
+			pen.text("WORLD", Math::PI)
+		end
+		assert(image == load_image('test_text.gd2'))
+	end
+
+	def test_text_circle
+		image = new_image
+		image.draw do |pen|
+			pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+			pen.font = GD2::Font::TrueType[PATH_TO_FONT, 32]
+			pen.move_to(128, 128)
+			pen.text_circle('HELLO', 'WORLD', 100, 20, 1)
+		end
+		assert(image == load_image('test_text_circle.gd2'))
+	end
+
+	def test_wedge
+		image = new_image
+		image.draw do |pen|
+			pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+			pen.wedge(128, 128, 256, 256, 0..180)
+		end
+		assert(image == load_image('test_wedge.gd2'))
+	end
+
+	def test_filled_wedge
+		image = new_image
+		image.draw do |pen|
+			pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+			pen.wedge(128, 128, 256, 256, 0..180, true)
+		end
+		assert(image == load_image('test_filled_wedge.gd2'))
+	end
+
+	def test_ellipse
+		image = new_image
+		image.draw do |pen|
+			pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+			pen.ellipse(128, 128, 64, 32)
+		end
+		assert(image == load_image('test_ellipse.gd2'))
+	end
+
+	def test_filled_ellipse
+		image = new_image
+		image.draw do |pen|
+			pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+			pen.ellipse(128, 128, 64, 32, true)
+		end
+		assert(image == load_image('test_filled_ellipse.gd2'))
+	end
+
+	def test_circle
+		image = new_image
+		image.draw do |pen|
+			pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+			pen.circle(128, 128, 128)
+		end
+		assert(image == load_image('test_circle.gd2'))
+	end
+
+	def test_filled_circle
+		image = new_image
+		image.draw do |pen|
+			pen.color = image.palette.resolve(GD2::Color[32, 64, 128])
+			pen.circle(128, 128, 128, true)
+		end
+		assert(image == load_image('test_filled_circle.gd2'))
+	end
+
+	def test_fill_to
+		image = new_image
+		image.draw do |pen|
+			blue = image.palette.resolve(GD2::Color[32, 64, 128])
+			red	= image.palette.resolve(GD2::Color[255, 0, 0])
+			pen.color = blue
+			pen.arc(128, 128, 256, 64, 0..(Math::PI))
+			pen.color = red
+			pen.move(128, 128)
+			pen.fill_to(blue)
+		end
+		assert(image == load_image('test_fill_to.gd2'))
+	end
 end

data/test/image_test.rb

@@ -4,146 +4,146 @@ require 'tmpdir'
 require 'rubygems'
 require 'gd2-ffij'
 
-require 'test/test_helper'
+require './test/test_helper'
 
 class ImageTest < Test::Unit::TestCase
-  include TestHelper
-
-  def test_image_new_and_release
-    img = GD2::Image.new(50, 50)
-  end
-
-  def test_image_true_color_new_and_release
-    img = GD2::Image::TrueColor.new(50, 50)
-  end
-
-  def test_image_indexed_color_new_and_release
-    img = GD2::Image::IndexedColor.new(50, 50)
-  end
-
-  [ :png, :gif, :jpg, :wbmp, :gd2 ].each do |ext|
-    self.class_eval(<<-EOF)
-      def test_load_#{ext}_from_file
-        img = GD2::Image.load(File.open(File.join(PATH_TO_IMAGES, 'test.#{ext}')))
-      end
-
-      def test_load_#{ext}_from_string
-        img = GD2::Image.load(File.read(File.join(PATH_TO_IMAGES, 'test.#{ext}')))
-      end
-    EOF
-  end
-
-  # TODO: add xbm, xpm and wbmp tests
-  [ :png, :gif, :jpg, :gd, :gd2 ].each do |ext|
-    self.class_eval(<<-EOF)
-      def test_import_#{ext}_from_file
-        img = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
-      end
-
-      def test_export_#{ext}
-        img = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.gd2'))
-        out = File.join(Dir.tmpdir, 'test.#{ext}')
-        img.export(out)
-
-        assert(File.exists?(out))
-
-        imgA = GD2::Image.import(out)
-        imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
-
-        assert(imgA == imgB)
-
-        File.unlink(out)
-      end
-
-      def test_compare_#{ext}
-        imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
-        imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
-        assert_equal(imgA.compare(imgB), 0)
-        assert_equal(imgA.compare(imgA.dup), 0)
-      end
-
-      def test_eqeq_#{ext}
-        imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
-        imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
-        assert(imgA == imgB)
-        assert(imgA == imgA.dup)
-      end
-
-      def test_height_#{ext}
-        img = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
-        assert_equal(img.height, 256)
-      end
-
-      def test_width_#{ext}
-        img = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
-        assert_equal(img.width, 256)
-      end
-
-      def test_size_#{ext}
-        img = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
-        assert_equal(img.size, [ 256, 256 ])
-      end
-
-      def test_aspect_#{ext}
-        img = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
-        assert_in_delta(img.aspect, 1.0, 0.00000001)
-      end
-    EOF
-  end
-
-  def test_rotate
-    imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.gd2')).rotate!(Math::PI)
-    imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_rotated_180.gd2'))
-
-    assert(imgA == imgB)
-  end
-
-  def test_crop
-    imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.gd2')).crop!(64, 64, 128, 128)
-    imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_cropped.gd2'))
-
-    assert(imgA == imgB)
-  end
-
-  def test_uncrop
-    img = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.gd2')).crop!(64, 64, 128, 128)
-    img.uncrop!(64)
-
-    assert_equal(img.size, [ 256, 256 ])
-  end
-
-  def test_resize
-    imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.gd2')).resize!(512, 512)
-    imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_resized.gd2'))
-
-    assert(imgA == imgB)
-  end
-
-  def test_resampled
-    imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.gd2')).resize!(512, 512, true)
-    imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_resampled.gd2'))
-
-    assert(imgA == imgB)
-  end
-
-  def test_polar_transform
-    imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.gd2')).polar_transform!(100)
-    imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_polar_transform.gd2'))
-
-    assert(imgA == imgB)
-  end
+	include TestHelper
+
+	def test_image_new_and_release
+		img = GD2::Image.new(50, 50)
+	end
+
+	def test_image_true_color_new_and_release
+		img = GD2::Image::TrueColor.new(50, 50)
+	end
+
+	def test_image_indexed_color_new_and_release
+		img = GD2::Image::IndexedColor.new(50, 50)
+	end
+
+	[ :png, :gif, :jpg, :wbmp, :gd2 ].each do |ext|
+		self.class_eval(<<-EOF)
+			def test_load_#{ext}_from_file
+				img = GD2::Image.load(File.open(File.join(PATH_TO_IMAGES, 'test.#{ext}')))
+			end
+
+			def test_load_#{ext}_from_string
+				img = GD2::Image.load(File.read(File.join(PATH_TO_IMAGES, 'test.#{ext}')))
+			end
+		EOF
+	end
+
+	# TODO: add xbm, xpm and wbmp tests
+	[ :png, :gif, :jpg, :gd, :gd2 ].each do |ext|
+		self.class_eval(<<-EOF)
+			def test_import_#{ext}_from_file
+				img = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
+			end
+
+			def test_export_#{ext}
+				img = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.gd2'))
+				out = File.join(Dir.tmpdir, 'test.#{ext}')
+				img.export(out)
+
+				assert(File.exists?(out))
+
+				imgA = GD2::Image.import(out)
+				imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
+
+				assert(imgA == imgB)
+
+				File.unlink(out)
+			end
+
+			def test_compare_#{ext}
+				imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
+				imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
+				assert_equal(imgA.compare(imgB), 0)
+				assert_equal(imgA.compare(imgA.dup), 0)
+			end
+
+			def test_eqeq_#{ext}
+				imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
+				imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
+				assert(imgA == imgB)
+				assert(imgA == imgA.dup)
+			end
+
+			def test_height_#{ext}
+				img = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
+				assert_equal(img.height, 256)
+			end
+
+			def test_width_#{ext}
+				img = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
+				assert_equal(img.width, 256)
+			end
+
+			def test_size_#{ext}
+				img = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
+				assert_equal(img.size, [ 256, 256 ])
+			end
+
+			def test_aspect_#{ext}
+				img = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
+				assert_in_delta(img.aspect, 1.0, 0.00000001)
+			end
+		EOF
+	end
+
+	def test_rotate
+		imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.gd2')).rotate!(Math::PI)
+		imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_rotated_180.gd2'))
+
+		assert(imgA == imgB)
+	end
+
+	def test_crop
+		imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.gd2')).crop!(64, 64, 128, 128)
+		imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_cropped.gd2'))
+
+		assert(imgA == imgB)
+	end
+
+	def test_uncrop
+		img = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.gd2')).crop!(64, 64, 128, 128)
+		img.uncrop!(64)
+
+		assert_equal(img.size, [ 256, 256 ])
+	end
+
+	def test_resize
+		imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.gd2')).resize!(512, 512)
+		imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_resized.gd2'))
+
+		assert(imgA == imgB)
+	end
+
+	def test_resampled
+		imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.gd2')).resize!(512, 512, true)
+		imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_resampled.gd2'))
+
+		assert(imgA == imgB)
+	end
+
+	def test_polar_transform
+		imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.gd2')).polar_transform!(100)
+		imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_polar_transform.gd2'))
+
+		assert(imgA == imgB)
+	end
 
-  def test_color_sharpened
-    imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_color.gd2')).sharpen(100)
-    imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_color_sharpened.gd2'))
+	def test_color_sharpened
+		imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_color.gd2')).sharpen(100)
+		imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_color_sharpened.gd2'))
 
-    assert(imgA == imgB)
-  end
+		assert(imgA == imgB)
+	end
 
-  def test_resampled
-    imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_color.gd2')).to_indexed_color
-    imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_color_indexed.gd2'))
+	def test_resampled
+		imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_color.gd2')).to_indexed_color
+		imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test_color_indexed.gd2'))
 
-    assert(imgA == imgB)
-  end
+		assert(imgA == imgB)
+	end
 end

data/test/test_helper.rb

@@ -1,13 +1,13 @@
 
 module TestHelper
-  PATH_TO_IMAGES = File.join(File.dirname(__FILE__), 'images')
-  PATH_TO_FONT   = File.join(File.dirname(__FILE__), '..', 'vendor', 'fonts', 'ttf', 'DejaVuSans.ttf')
+	PATH_TO_IMAGES = File.join(File.dirname(__FILE__), 'images')
+	PATH_TO_FONT   = File.join(File.dirname(__FILE__), '..', 'vendor', 'fonts', 'ttf', 'DejaVuSans.ttf')
 
 	def new_image
-    GD2::Image.new(256, 256)
+	    GD2::Image.new(256, 256)
 	end
 
 	def load_image(file_name)
-    GD2::Image.load(File.read(File.join(PATH_TO_IMAGES, file_name)))
+	    GD2::Image.load(File.read(File.join(PATH_TO_IMAGES, file_name)))
 	end
 end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: gd2-ffij
 version: !ruby/object:Gem::Version 
+  hash: 25
   prerelease: false
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - J Smith
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-13 00:00:00 -05:00
+date: 2010-11-11 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -92,23 +93,27 @@ 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.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: gd2-ffij is a refactoring of the Ruby/GD2 library implemented with FFI