spatrik-gd2-ffi 0.0.3

data/README.md

@@ -0,0 +1,39 @@
+gd2-ffi
+=======
+
+gd2-ffi is ruby bindings for gd2, implemented with [FFI][FFI]
+
+  [FFI]: http://kenai.com
+  
+The bindings are currently very incomplete, only including what I need for a certain project (Creating truecolor images, drawing rectangles, drawing TrueType fonts). 
+
+It follows the same API as the [gd2 gem][GD2-GEM]
+
+  [GD2-GEM]: http://gd2.rubyforge.org/
+
+The reason for building this gem is that the other gd2 gem had problems with segfaulting on some linux boxes, and it was more fun and quicker to learn FFI than debug dlopen (Which I have no idea how it works) :)¨
+
+License
+-------
+
+The MIT License
+
+Copyright (c) 2009 Patrik Stenmark
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "gd2-ffi"
+    gem.summary = %Q{gd2-ffi is ruby bindings for gd2, implemented with ffi}
+    gem.description = %Q{gd2-ffi is ruby bindings for gd2, implemented with ffi}
+    gem.email = "patrik.stenmark@gmail.com"
+    gem.homepage = "http://github.com/spatrik/gd2-ffi"
+    gem.authors = ["Patrik Stenmark"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+
+
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "test #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.3

data/gd2-ffi.gemspec

@@ -0,0 +1,57 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{gd2-ffi}
+  s.version = "0.0.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Patrik Stenmark"]
+  s.date = %q{2009-08-05}
+  s.description = %q{gd2-ffi is ruby bindings for gd2, implemented with ffi}
+  s.email = %q{patrik.stenmark@gmail.com}
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    "README.md",
+     "Rakefile",
+     "VERSION",
+     "gd2-ffi.gemspec",
+     "lib/gd2-ffi.rb",
+     "lib/gd2/canvas.rb",
+     "lib/gd2/cgd2.rb",
+     "lib/gd2/color.rb",
+     "lib/gd2/font.rb",
+     "lib/gd2/image.rb",
+     "spec/Vera.ttf",
+     "spec/canvas_spec.rb",
+     "spec/color_spec.rb",
+     "spec/image_spec.rb",
+     "spec/spec_helper.rb",
+     "test.rb"
+  ]
+  s.homepage = %q{http://github.com/spatrik/gd2-ffi}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{gd2-ffi is ruby bindings for gd2, implemented with ffi}
+  s.test_files = [
+    "spec/canvas_spec.rb",
+     "spec/color_spec.rb",
+     "spec/image_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/lib/gd2/canvas.rb

@@ -0,0 +1,34 @@
+module GD2
+  class Canvas
+    class Point
+      attr_accessor :x, :y
+      def initialize(x, y)
+        @x, @y = x, y
+      end
+    end
+    
+    class Text
+      def initialize(font, point, angle, string)
+        @font, @point, @angle, @string = font, point, angle, string
+      end
+      
+      def draw(image, color)
+        color = color.is_a?(Color) ? color.rgba : color
+        @font.draw(image.image_ptr, @point.x, @point.y, @angle, @string, color)
+      end
+    end
+    
+    class FilledRectangle
+      def initialize(point1, point2)
+        @p1, @p2 = point1, point2
+      end
+
+      def draw(image, color)
+        color = color.is_a?(GD2::Color) ? color.rgba : color
+        
+        CGD2::gdImageFilledRectangle(image.image_ptr, @p1.x, @p1.y, @p2.x, @p2.y, color)
+        nil
+      end
+    end
+  end
+end

data/lib/gd2/cgd2.rb

@@ -0,0 +1,26 @@
+module CGD2
+  
+  def self.lib_paths
+     ["/opt/local/lib/libgd.2.dylib", '/usr/lib/libgd.so.2']
+  end
+  extend FFI::Library
+  ffi_lib *lib_paths
+  
+  # BGD_DECLARE(gdImagePtr) gdImageCreate (int sx, int sy)
+  attach_function :gdImageCreate, [:int, :int], :pointer
+  attach_function :gdImageCreateTrueColor, [:int, :int], :pointer
+  
+  # void gdImageFilledRectangle(gdImagePtr im, int x1, int y1, int x2, int y2, int color) (FUNCTION)
+  attach_function :gdImageFilledRectangle, [:pointer, :int, :int, :int, :int, :int], :void
+  
+  #char *gdImageStringFT(gdImagePtr im, int *brect, int fg, char *fontname, double ptsize, double angle, int x, int y, char *string) (FUNCTION)
+  attach_function :gdImageStringFT, [:pointer, :pointer, :int, :string, :double, :double, :int, :int, :string], :pointer
+  
+  # void* gdImagePngPtr(gdImagePtr im, int *size) (FUNCTION)
+  attach_function :gdImagePngPtr, [:pointer, :pointer], :pointer
+  
+  # gdImageDestroy(gdImagePtr im) (FUNCTION)
+  attach_function :gdImageDestroy, [:pointer], :void
+  
+  attach_function :gdFree, [:pointer], :void
+end

data/lib/gd2/color.rb

@@ -0,0 +1,110 @@
+module GD2
+  class Color
+    attr_reader :rgba
+    alias :to_i :rgba
+    class << self
+      alias [] new
+    end
+    
+    def initialize(r, g, b, a = ALPHA_OPAQUE)
+      r = self.class.normalize(r, RGB_MAX, :red)
+      g = self.class.normalize(g, RGB_MAX, :green)
+      b = self.class.normalize(b, RGB_MAX, :blue)
+      a = self.class.normalize(a, ALPHA_MAX, :alpha)
+
+      init_with_rgba(self.class.pack(r, g, b, a))
+    end
+    
+    def init_with_rgba(rgba, index = nil, palette = nil)  #:nodoc:
+      @rgba = rgba
+      @index = index
+      @palette = palette
+      self
+    end
+    
+    def self.pack(r, g, b, a)   #:nodoc:
+      (a << 24) + (r << 16) + (g << 8) + b
+    end
+    
+    def to_s
+      s  = 'RGB'
+      s += "A" if alpha != ALPHA_OPAQUE
+      s += "[#{@index}]" if @index
+      s += '#' + [red, green, blue].map { |e| '%02X' % e }.join('')
+      s += '%02X' % alpha if alpha != ALPHA_OPAQUE
+      s
+    end
+    
+    
+    def self.normalize(value, max, component = nil)   #:nodoc:
+      case value
+      when Integer
+        (value < 0) ? 0 : (value > max) ? max : value
+      when Float
+        normalize((value * max).round, max, component)
+      when Color
+        value.send(component)
+      else
+        return normalize(value.to_i, max) if value.respond_to?(:to_i)
+        raise TypeError
+      end
+    end
+    # Return the red component of this color (0..RGB_MAX).
+    def red
+      (rgba & 0xFF0000) >> 16
+    end
+    alias r red
+
+    # Modify the red component of this color. If this color is associated
+    # with a palette entry, this also modifies the palette.
+    #def red=(value)
+    #  self.rgba = (rgba & ~0xFF0000) |
+    #    (self.class.normalize(value, RGB_MAX, :red) << 16)
+    #end
+    #alias r= red=
+
+    # Return the green component of this color (0..RGB_MAX).
+    def green
+      (rgba & 0x00FF00) >> 8
+    end
+    alias g green
+
+    # Modify the green component of this color. If this color is associated
+    # with a palette entry, this also modifies the palette.
+    #def green=(value)
+    #  self.rgba = (rgba & ~0x00FF00) |
+    #    (self.class.normalize(value, RGB_MAX, :green) << 8)
+    #end
+    #alias g= green=
+
+    # Return the blue component of this color (0..RGB_MAX).
+    def blue
+      rgba & 0x0000FF
+    end
+    alias b blue
+
+    # Modify the blue component of this color. If this color is associated
+    # with a palette entry, this also modifies the palette.
+    #def blue=(value)
+    #  self.rgba = (rgba & ~0x0000FF) |
+    #    self.class.normalize(value, RGB_MAX, :blue)
+    #end
+    #alias b= blue=
+
+    # Return the alpha component of this color (0..ALPHA_MAX).
+    def alpha
+      (rgba & 0x7F000000) >> 24
+    end
+    alias a alpha
+
+    # Modify the alpha component of this color. If this color is associated
+    # with a palette entry, this also modifies the palette.
+    def alpha=(value)
+      self.rgba = (rgba & ~0xFF000000) |
+        (self.class.normalize(value, ALPHA_MAX, :alpha) << 24)
+    end
+    alias a= alpha=
+    
+    
+  end
+end

data/lib/gd2/font.rb

@@ -0,0 +1,95 @@
+module GD2
+  class Font
+    class TrueType
+      
+      class FreeTypeError < StandardError ; end
+      def initialize(fontname, ptsize, options = {})
+        @fontname, @ptsize = fontname, ptsize
+        
+        # since no start of cache, no register!
+        # do the font path getting?
+      end
+      
+      def draw(image_ptr, x, y, angle, string, fg)
+        brect = FFI::MemoryPointer.new(:int, 8)
+        string = string.gsub('&', '&amp;')
+        error = CGD2::gdImageStringFT(image_ptr, brect, fg, @fontname, @ptsize, angle.to_f, x, y, string)
+        
+        
+        raise FreeTypeError, error unless error.null?
+        
+        brect = brect.read_array_of_int(8)
+        
+        { :lower_left   => [brect[0], brect[1]],
+          :lower_right  => [brect[2], brect[3]],
+          :upper_right  => [brect[4], brect[5]],
+          :upper_left   => [brect[6], brect[7]]
+          #:position     => position
+        }
+        
+      end
+      
+      # Return a hash describing the rectangle that would enclose the given
+      # string rendered in this font at the given angle. The returned hash
+      # contains the following keys:
+      #
+      # - :lower_left => The [x, y] coordinates of the lower left corner.
+      # - :lower_right => The [x, y] coordinates of the lower right corner.
+      # - :upper_right => The [x, y] coordinates of the upper right corner.
+      # - :upper_left => The [x, y] coordinates of the upper left corner.
+      # - :position => An array of floating point character position offsets for
+      #   each character of the +string+, beginning with 0.0. The array also
+      #   includes a final position indicating where the last character ends.
+      #
+      # The _upper_, _lower_, _left_, and _right_ references are relative to the
+      # text of the +string+, regardless of the +angle+.
+      def bounding_rectangle(string, angle = 0.0)
+        data = draw(nil, 0, 0, angle, string, 0)
+
+        #if string.length == 1
+        #  # gd annoyingly fails to provide xshow data for strings of length 1
+        #  position = draw(nil, 0, 0, angle, string + ' ', 0)[:position]
+        #  data[:position] = position[0...-1]
+        #end
+
+        data
+      end
+      
+    end
+    
+  end
+end
+
+#def draw(image_ptr, x, y, angle, string, fg)  #:nodoc:
+#  brect = Array.new(8) { 0 }
+#  strex = strex(true)
+#  r, rs = SYM[:gdImageStringFTEx].call(image_ptr,
+#    brect, fg, @fontname, @ptsize, angle.to_f, x, y,
+#    string.gsub('&', '&amp;'), strex)
+#  raise FreeTypeError, r if r
+#
+#  brect = rs[1].to_a('I', 8)
+#
+#  if xshow = strex[:xshow]
+#    xshow.free = SYM[:gdFree]
+#    xshow = xshow.to_s.split(' ').map { |e| e.to_f }
+#  else
+#    xshow = []
+#  end
+#
+#  sum = 0.0
+#  position = Array.new(xshow.length + 1)
+#  xshow.each_with_index do |advance, i|
+#    position[i] = sum
+#    sum += advance
+#  end
+#  position[-1] = sum
+#
+#  { :lower_left   => [brect[0], brect[1]],
+#    :lower_right  => [brect[2], brect[3]],
+#    :upper_right  => [brect[4], brect[5]],
+#    :upper_left   => [brect[6], brect[7]],
+#    :position     => position
+#  }
+#end
+#

data/lib/gd2/image.rb

@@ -0,0 +1,36 @@
+module GD2
+  class Image
+    attr_reader :image_ptr
+    
+    
+  end
+  
+  class Image::IndexedColor < Image
+    
+  end
+  
+  class Image::TrueColor < Image
+    def release(ptr)
+      CGD2::gdImageDestroy(ptr)
+    end
+    def initialize(w, h)
+      @image_ptr = FFI::AutoPointer.new(
+        CGD2::gdImageCreateTrueColor(w, h), 
+        self.method(:release)
+      )
+    end
+    
+    def png
+      size = FFI::MemoryPointer.new(:pointer)
+      png_pointer = CGD2.gdImagePngPtr(@image_ptr, size)
+      
+      size = size.get_int(0)
+      
+      png = png_pointer.get_bytes(0, size)
+      
+      CGD2::gdFree(png_pointer)
+      
+      png
+    end
+  end
+end

data/lib/gd2-ffi.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'ffi'
+
+require 'gd2/cgd2'
+require 'gd2/image'
+require 'gd2/font'
+require 'gd2/canvas'
+require 'gd2/color'
+
+module GD2
+  
+  ALPHA_MAX         = 127
+  ALPHA_OPAQUE      =   0
+  ALPHA_TRANSPARENT = 127
+  
+  RGB_MAX           = 255
+end

data/spec/canvas_spec.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe "Canvas" do
+  before do
+    @image = GD2::Image::TrueColor.new(100, 100)
+    @black = GD2::Color[0,0,0]
+  end
+  
+  describe "FilledRectangle" do
+    it "should intitialze by two gd points" do
+      p1 = GD2::Canvas::Point.new(0,0)
+      p2 = GD2::Canvas::Point.new(10,10)
+      GD2::Canvas::FilledRectangle.new(p1, p2)
+    end
+    
+    it "should call GD draw function" do
+      CGD2.should_receive(:gdImageFilledRectangle).with(anything, 0, 0, 10, 10, 0)
+      p1 = GD2::Canvas::Point.new(0,0)
+      p2 = GD2::Canvas::Point.new(10,10)
+      
+      rect = GD2::Canvas::FilledRectangle.new(p1, p2)
+      
+      rect.draw(@image, @black.to_i)
+    end
+    
+    it "should convert Color to int" do
+      CGD2.should_receive(:gdImageFilledRectangle).with(anything, 0, 0, 10, 10, 0)
+      p1 = GD2::Canvas::Point.new(0,0)
+      p2 = GD2::Canvas::Point.new(10,10)
+      
+      rect = GD2::Canvas::FilledRectangle.new(p1, p2)
+      
+      rect.draw(@image, @black)
+    end
+  end
+  
+  describe "TrueType" do
+    it "should find out the font path"
+    
+    it "should call C function on draw" do
+      font = GD2::Font::TrueType.new(
+        "Vera.ttf",
+        10.0
+      )
+      
+      p_text = GD2::Canvas::Point.new(1,2)
+      
+      
+      CGD2.should_receive(:gdImageStringFT).with(anything, anything, @black.to_i, "Vera.ttf", 10.0, 0.0, 1, 2, "foobar").and_return(mock("Pointer", :null? => true))
+      
+      text = GD2::Canvas::Text.new(font, p_text, 0, "foobar")
+      text.draw(@image, @black)
+    end
+    
+    it "should raise a FreeTypeError if the C call is unsuccesful" do
+      font = GD2::Font::TrueType.new(
+        "Vera.ttf",
+        10.0
+      )
+      
+      p_text = GD2::Canvas::Point.new(1,2)
+      text = GD2::Canvas::Text.new(font, p_text, 0, "foobar")
+      
+      CGD2.stub!(:gdImageStringFT).and_return(mock("Nullpointer", :null? => false))
+      lambda {
+        text.draw(@image, @black)
+        
+      }.should raise_error(GD2::Font::TrueType::FreeTypeError)
+    end
+  end
+end

data/spec/color_spec.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe GD2::Color do
+  it "should initialize from int" do
+    GD2::Color.new(50,100,200).rgba.should eql(3302600)
+  end
+  
+  it "should initialize with []" do
+    GD2::Color[50,100,200].rgba.should eql(3302600)
+  end
+  
+  it "should have to_i" do
+    color = GD2::Color[50,100,200]
+    color.rgba.should eql(3302600)
+    color.to_i.should eql(color.rgba)
+  end
+  
+  [
+    [:red, 50],
+    [:green, 100],
+    [:blue, 200]
+  ].each do |color_name, value|
+    it "should return the #{color_name} value" do
+      color = GD2::Color[50,100,200]
+      color.send(color_name).should eql(value)
+    end
+    
+    it "should return color #{color_name} by first letter" do
+      color_name = color_name.to_s[0..0].to_sym
+      color = GD2::Color[50,100,200]
+      color.send(color_name).should eql(value)
+    end
+  end
+  
+  
+end

data/spec/image_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe GD2::Image::TrueColor do
+  before do
+    CGD2.stub!(:gdFree)
+  end
+  it "should generate png string" do
+    image = GD2::Image::TrueColor.new(100, 100)
+    CGD2.should_receive(:gdImagePngPtr).and_return(mock("Pointer", :get_bytes => ''))
+    
+    image.png
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'rbconfig'
+require 'spec'
+
+$: << 'lib'
+require 'gd2-ffi'

data/test.rb

@@ -0,0 +1,50 @@
+$: << 'lib'
+require 'gd2'
+image_height = 100
+image_width = 200
+
+options = {
+  :offset_x => 1,
+  :margin => 10,
+  :offset_y => 10, 
+  :line_spacing => 2
+}
+line = "foobar"
+
+
+font = GD2::Font::TrueType.new(
+  "Vera.ttf",
+  10.0
+)
+
+black = GD2::Color[0.0, 0.0, 0.0]
+
+p1 = GD2::Canvas::Point.new(0,0)
+p2 = GD2::Canvas::Point.new(image_width, image_height)
+p3 = GD2::Canvas::Point.new(image_width, 0)
+p4 = GD2::Canvas::Point.new(image_width * 2, image_height)
+
+bg_rect = GD2::Canvas::FilledRectangle.new(p1, p2)
+bg_rect_sprite = GD2::Canvas::FilledRectangle.new(p3, p4)
+
+white = GD2::Color[1.0, 1.0, 1.0]
+yellow = GD2::Color[1.0, 0.8, 0.0]
+
+p_text = GD2::Canvas::Point.new(
+  options[:offset_x] + options[:margin],
+  options[:offset_y] + options[:line_spacing] * (0 + 1))
+
+image = GD2::Image::TrueColor.new(image_width * 2, image_height)
+bg_rect.draw(image, white.to_i)
+bg_rect_sprite.draw(image, yellow.to_i)
+
+text = GD2::Canvas::Text.new(font, p_text, 0, line)
+begin
+  text.draw(image, black)
+rescue => e
+  puts e.message
+end
+
+File.open("foo.png", "wb") do |file|
+  file.write(image.png)
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: spatrik-gd2-ffi
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+platform: ruby
+authors: 
+- Patrik Stenmark
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-05 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: gd2-ffi is ruby bindings for gd2, implemented with ffi
+email: patrik.stenmark@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- README.md
+- Rakefile
+- VERSION
+- gd2-ffi.gemspec
+- lib/gd2-ffi.rb
+- lib/gd2/canvas.rb
+- lib/gd2/cgd2.rb
+- lib/gd2/color.rb
+- lib/gd2/font.rb
+- lib/gd2/image.rb
+- spec/Vera.ttf
+- spec/canvas_spec.rb
+- spec/color_spec.rb
+- spec/image_spec.rb
+- spec/spec_helper.rb
+- test.rb
+has_rdoc: false
+homepage: http://github.com/spatrik/gd2-ffi
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: gd2-ffi is ruby bindings for gd2, implemented with ffi
+test_files: 
+- spec/canvas_spec.rb
+- spec/color_spec.rb
+- spec/image_spec.rb
+- spec/spec_helper.rb