jemmyw-image_science 1.3.2.1.Asynchrony

data/.gitignore

@@ -0,0 +1,9 @@
+pkg/*
+*.gem
+.bundle
+mkmf.log
+Makefile
+*.so
+*.o
+*.bundle
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in number_with_error.gemspec
+gemspec
+gem "rake"

data/History.txt

@@ -0,0 +1,77 @@
+=== 1.2.1 / 2009-08-14
+
+* 2 minor enhancements:
+
+  * Added luis' patches to make it build properly on windows.
+  * with_image now raises on missing/bad files.
+
+== 1.2.0 / 2009-06-23
+
+* 7 minor enhancements:
+
+  *	Moved quick_thumb to bin/image_science_thumb and properly added.
+  * Added -s (square) flag to bin/image_science_thumb
+  * Added autorotating on image load. (choonkeat)
+  * Added ruby_inline to clean globs
+  * Added with_image_from_memory. (sumbach)
+  * Switched to minitest.
+  * Updated rakefile for now hoe capabilities.
+
+* 3 bug fixes:
+
+  * Check and convert to 24 BPP if save type is jpg. Caused by 32bpp png to jpg.
+  * Fixed 1.9isms
+  * Fixed BMP support. Tweaked whitespace.
+
+== 1.1.3 / 2007-05-30
+
+* 2 minor enhancements:
+
+  * Added quick_thumb as an example to look at.
+  * Error handler doesn't raise by default. Raises if $DEBUG==true.
+
+== 1.1.2 / 2007-04-18
+
+* 2 bug fixes:
+
+  * reports bad height/width values for resize
+  * explicitly removes ICC color profiles from PNGs (bug in freeimage).
+
+== 1.1.1 / 2007-03-08
+
+* 5 minor enhancements:
+
+  * Added error handler that raises with information about what went wrong.
+  * thumbnail is now pure ruby, everything now uses resize.
+  * Produces cleaner JPEG files, with a small cost to file size/speed.
+  * resize now uses Catmull-Rom spline filter for better quality.
+  * resize copies existing ICC Profile to thumbnail, producing better color.
+  * ICC Profile NOT copied for PNG as it seems to be buggy.
+
+* 1 bug fix:
+
+  * Fixed rdoc
+
+== 1.1.0 / 2007-01-05
+
+* 3 major enhancements:
+
+  * Added resize(width, height)
+  * Added save(path)
+  * All thumbnail and resize methods yield instead of saving directly.
+
+* 1 minor enhancement:
+
+  * Will now try to use FreeImage from ports if /opt/local exists.
+
+* 2 bug fixes:
+
+  * Fixed the linker issue on PPC.
+  * Rakefile will now clean the image files created by bench.rb
+
+== 1.0.0 / 2006-12-01
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,9 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bench.rb
+bin/image_science_thumb
+lib/image_science.rb
+test/pix.png
+test/test_image_science.rb

data/README.txt

@@ -0,0 +1,66 @@
+= ImageScience
+
+* http://seattlerb.rubyforge.org/ImageScience.html
+* http://rubyforge.org/projects/seattlerb
+
+== DESCRIPTION:
+
+ImageScience is a clean and happy Ruby library that generates
+thumbnails -- and kicks the living crap out of RMagick. Oh, and it
+doesn't leak memory like a sieve. :)
+
+For more information including build steps, see http://seattlerb.rubyforge.org/
+
+== FEATURES/PROBLEMS:
+
+* Glorious graphics manipulation magi... errr, SCIENCE! in less than 200 LoC!
+* Supports square and proportional thumbnails, as well as arbitrary resizes.
+* Pretty much any graphics format you could want. No really.
+
+== SYNOPSYS:
+
+  ImageScience.with_image(file) do |img|
+    img.cropped_thumbnail(100) do |thumb|
+      thumb.save "#{file}_cropped.png"
+    end
+
+    img.thumbnail(100) do |thumb|
+      thumb.save "#{file}_thumb.png"
+    end
+  end
+
+== REQUIREMENTS:
+
+* FreeImage
+* ImageScience
+
+== INSTALL:
+
+* Download and install FreeImage. See notes at url above.
+* sudo gem install -y image_science
+* see http://seattlerb.rubyforge.org/ImageScience.html for more info.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2006-2009 Ryan Davis, Seattle.rb
+
+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,16 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+task :build => [:compile, :chmod]
+
+task :compile do
+  `ruby ext/image_science/extconf.rb`
+  `make`
+  `mv extension.so lib/image_science/extension.so`
+  `mv extension.bundle lib/image_science/extension.bundle`
+end
+
+task :chmod do
+  File.chmod(0775, 'lib/image_science/extension.so')
+end
+

data/bench.rb

@@ -0,0 +1,63 @@
+#!/usr/local/bin/ruby -w
+
+require 'benchmark'
+require 'rubygems'
+require 'image_science'
+
+max = (ARGV.shift || 100).to_i
+ext = ARGV.shift || "png"
+
+file = "blah_big.#{ext}"
+
+if RUBY_PLATFORM =~ /darwin/ then
+  # how fucking cool is this???
+  puts "taking screenshot for thumbnailing benchmarks"
+  system "screencapture -SC #{file}"
+else
+  abort "You need to plonk down #{file} or buy a mac"
+end unless test ?f, "#{file}"
+
+ImageScience.with_image(file.sub(/#{ext}$/, 'png')) do |img|
+  img.save(file)
+end if ext != "png"
+
+puts "# of iterations = #{max}"
+Benchmark::bm(20) do |x|
+  x.report("null_time") {
+    for i in 0..max do
+      # do nothing
+    end
+  }
+
+  x.report("cropped") {
+    for i in 0..max do
+      ImageScience.with_image(file) do |img|
+        img.cropped_thumbnail(100) do |thumb|
+          thumb.save("blah_cropped.#{ext}")
+        end
+      end
+    end
+  }
+
+  x.report("proportional") {
+    for i in 0..max do
+      ImageScience.with_image(file) do |img|
+        img.thumbnail(100) do |thumb|
+          thumb.save("blah_thumb.#{ext}")
+        end
+      end
+    end
+  }
+
+  x.report("resize") {
+    for i in 0..max do
+      ImageScience.with_image(file) do |img|
+        img.resize(200, 200) do |resize|
+          resize.save("blah_resize.#{ext}")
+        end
+      end
+    end
+  }
+end
+
+# File.unlink(*Dir["blah*#{ext}"])

data/bin/image_science_thumb

@@ -0,0 +1,31 @@
+#!/usr/local/bin/ruby -ws
+
+$s ||= false
+
+abort "#{File.basename $0} max_length files..." unless ARGV.size > 1
+
+require 'rubygems'
+require 'image_science'
+
+max_length = ARGV.shift.to_i
+
+msg = $s ? :cropped_thumbnail : :thumbnail
+
+ARGV.each do |file|
+  begin
+    result = ImageScience.with_image file do |img|
+      begin
+        img.send(msg, max_length) do |thumb|
+          # add _thumb and switch from gif to png. Really. gif just sucks.
+          out = file.sub(/(\.[^\.]+)$/, '_thumb\1').sub(/gif$/, 'png')
+          thumb.save(out)
+        end
+      rescue => e
+        warn "Exception thumbnailing #{file}: #{e}"
+      end
+    end
+    p file => result
+  rescue => e
+    warn "Exception opening #{file}: #{e}"
+  end
+end

data/ext/image_science/extconf.rb

@@ -0,0 +1,10 @@
+require 'mkmf'
+
+include_path = '/usr/local/include:/usr/include'
+lib_path = '/usr/local/lib:/usr/lib'
+
+dir_config("image_science", include_path, lib_path)
+
+have_library('freeimage')
+
+create_makefile("image_science/extension")

data/ext/image_science/image_science.c

@@ -0,0 +1,256 @@
+#include "ruby.h"
+#include "FreeImage.h"
+
+#define GET_BITMAP(name) Data_Get_Struct(self, FIBITMAP, (name)); if (!(name)) rb_raise(rb_eTypeError, "Bitmap has already been freed");
+
+VALUE unload(VALUE self) {
+  FIBITMAP *bitmap;
+  GET_BITMAP(bitmap);
+
+  FreeImage_Unload(bitmap);
+  DATA_PTR(self) = NULL;
+  return Qnil;
+}
+
+
+VALUE wrap_and_yield(FIBITMAP *image, VALUE self, FREE_IMAGE_FORMAT fif) {
+  unsigned int self_is_class = rb_type(self) == T_CLASS;
+  VALUE klass = self_is_class ? self         : CLASS_OF(self);
+  VALUE type  = self_is_class ? INT2FIX(fif) : rb_iv_get(self, "@file_type");
+  VALUE obj = Data_Wrap_Struct(klass, NULL, NULL, image);
+  rb_iv_set(obj, "@file_type", type);
+  return rb_ensure(rb_yield, obj, unload, obj);
+}
+
+
+void copy_icc_profile(VALUE self, FIBITMAP *from, FIBITMAP *to) {
+  FREE_IMAGE_FORMAT fif = FIX2INT(rb_iv_get(self, "@file_type"));
+  if (fif != FIF_PNG && FreeImage_FIFSupportsICCProfiles(fif)) {
+    FIICCPROFILE *profile = FreeImage_GetICCProfile(from);
+    if (profile && profile->data) {
+      FreeImage_CreateICCProfile(to, profile->data, profile->size);
+    }
+  }
+}
+
+static char* lastFreeImageMessage = NULL;
+
+void FreeImageMessageHandler(FREE_IMAGE_FORMAT fif, const char *message) {
+  if (lastFreeImageMessage != NULL)
+    free(lastFreeImageMessage);
+
+  lastFreeImageMessage = strdup(message);
+}
+
+
+static VALUE with_image(VALUE self, VALUE _input) {
+  char * input = StringValuePtr(_input);
+
+  FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;
+  int flags;
+
+  fif = FreeImage_GetFileType(input, 0);
+  if (fif == FIF_UNKNOWN) fif = FreeImage_GetFIFFromFilename(input);
+  if ((fif != FIF_UNKNOWN) && FreeImage_FIFSupportsReading(fif)) {
+    FIBITMAP *bitmap;
+    VALUE result = Qnil;
+    flags = fif == FIF_JPEG ? JPEG_ACCURATE : 0;
+    if (bitmap = FreeImage_Load(fif, input, flags)) {
+      FITAG *tagValue = NULL;
+      FreeImage_GetMetadata(FIMD_EXIF_MAIN, bitmap, "Orientation", &tagValue);
+      switch (tagValue == NULL ? 0 : *((short *) FreeImage_GetTagValue(tagValue))) {
+        case 6:
+          bitmap = FreeImage_RotateClassic(bitmap, 270);
+          break;
+        case 3:
+          bitmap = FreeImage_RotateClassic(bitmap, 180);
+          break;
+        case 8:
+          bitmap = FreeImage_RotateClassic(bitmap, 90);
+          break;
+        default:
+         break;
+      }
+
+      result = wrap_and_yield(bitmap, self, fif);
+    } else {
+      rb_raise(rb_eTypeError, 
+              "Failed to load image from file %s: %s", 
+              input,
+              lastFreeImageMessage != NULL ? lastFreeImageMessage : "Unspecified error");
+    }
+
+    return (result);
+  }
+  rb_raise(rb_eTypeError, "Unknown file format");
+}
+
+
+static VALUE with_image_from_memory(VALUE self, VALUE _image_data) {
+  VALUE image_data = (_image_data);
+
+  FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;
+
+  Check_Type(image_data, T_STRING);
+  BYTE *image_data_ptr    = (BYTE*)RSTRING_PTR(image_data);
+  DWORD image_data_length = RSTRING_LEN(image_data);
+  FIMEMORY *stream = FreeImage_OpenMemory(image_data_ptr, image_data_length);
+
+  if (NULL == stream) {
+    rb_raise(rb_eTypeError, "Unable to open image_data");
+  }
+
+  fif = FreeImage_GetFileTypeFromMemory(stream, 0);
+  if ((fif == FIF_UNKNOWN) || !FreeImage_FIFSupportsReading(fif)) {
+    rb_raise(rb_eTypeError, "Unknown file format");
+  }
+
+  FIBITMAP *bitmap = NULL;
+  VALUE result = Qnil;
+  int flags = fif == FIF_JPEG ? JPEG_ACCURATE : 0;
+  bitmap = FreeImage_LoadFromMemory(fif, stream, flags);
+  FreeImage_CloseMemory(stream);
+  if (bitmap) {
+    result = wrap_and_yield(bitmap, self, fif);
+  }
+  return (result);
+}
+
+
+static VALUE with_crop(VALUE self, VALUE _l, VALUE _t, VALUE _r, VALUE _b) {
+  int l = FIX2INT(_l);
+  int t = FIX2INT(_t);
+  int r = FIX2INT(_r);
+  int b = FIX2INT(_b);
+
+  FIBITMAP *copy, *bitmap;
+  VALUE result = Qnil;
+  GET_BITMAP(bitmap);
+
+  if (copy = FreeImage_Copy(bitmap, l, t, r, b)) {
+    copy_icc_profile(self, bitmap, copy);
+    result = wrap_and_yield(copy, self, 0);
+  }
+  return (result);
+}
+
+
+static VALUE height(VALUE self) {
+
+  FIBITMAP *bitmap;
+  GET_BITMAP(bitmap);
+
+  return INT2FIX(FreeImage_GetHeight(bitmap));
+}
+
+
+static VALUE width(VALUE self) {
+
+  FIBITMAP *bitmap;
+  GET_BITMAP(bitmap);
+
+  return INT2FIX(FreeImage_GetWidth(bitmap));
+}
+
+
+static VALUE resize(VALUE self, VALUE _w, VALUE _h) {
+  long w = NUM2LONG(_w);
+  long h = NUM2LONG(_h);
+
+  FIBITMAP *bitmap, *image;
+  if (w <= 0) rb_raise(rb_eArgError, "Width <= 0");
+  if (h <= 0) rb_raise(rb_eArgError, "Height <= 0");
+  GET_BITMAP(bitmap);
+  image = FreeImage_Rescale(bitmap, w, h, FILTER_CATMULLROM);
+  if (image) {
+    copy_icc_profile(self, bitmap, image);
+    return (wrap_and_yield(image, self, 0));
+  }
+  return (Qnil);
+}
+
+
+static VALUE save(VALUE self, VALUE _output) {
+  char * output = StringValuePtr(_output);
+
+  int flags;
+  FIBITMAP *bitmap;
+  FREE_IMAGE_FORMAT fif = FreeImage_GetFIFFromFilename(output);
+  if (fif == FIF_UNKNOWN) fif = FIX2INT(rb_iv_get(self, "@file_type"));
+  if ((fif != FIF_UNKNOWN) && FreeImage_FIFSupportsWriting(fif)) {
+    GET_BITMAP(bitmap);
+    flags = fif == FIF_JPEG ? JPEG_QUALITYGOOD : 0;
+    BOOL result = 0, unload = 0;
+
+    if (fif == FIF_PNG) FreeImage_DestroyICCProfile(bitmap);
+    if (fif == FIF_JPEG && FreeImage_GetBPP(bitmap) != 24)
+      bitmap = FreeImage_ConvertTo24Bits(bitmap), unload = 1;
+
+    result = FreeImage_Save(fif, bitmap, output, flags);
+
+    if (unload) FreeImage_Unload(bitmap);
+
+    return (result ? Qtrue : Qfalse);
+  }
+  rb_raise(rb_eTypeError, "Unknown file format");
+}
+
+static VALUE bytes(VALUE self) {
+	FIMEMORY *hmem = NULL;
+	FIBITMAP *bitmap;
+	VALUE byte_string;
+	int flags;
+
+	FREE_IMAGE_FORMAT fif = FIX2INT(rb_iv_get(self, "@file_type"));
+
+	if ((fif != FIF_UNKNOWN) && FreeImage_FIFSupportsWriting(fif)) {
+		GET_BITMAP(bitmap);
+		flags = fif == FIF_JPEG ? JPEG_QUALITYGOOD : 0;
+		BOOL result = 0, unload = 0;
+
+		if (fif == FIF_PNG) FreeImage_DestroyICCProfile(bitmap);
+		if (fif == FIF_JPEG && FreeImage_GetBPP(bitmap) != 24)
+			bitmap = FreeImage_ConvertTo24Bits(bitmap), unload = 1;
+
+		// open and allocate a memory stream
+		hmem = FreeImage_OpenMemory(0, 0);
+		// save the image to a memory stream
+		result = FreeImage_SaveToMemory(fif, bitmap, hmem, flags);
+
+		if (unload) FreeImage_Unload(bitmap);
+
+		// get the buffer from the memory stream
+		BYTE *mem_buffer = NULL;
+		DWORD size_in_bytes = 0;
+		FreeImage_AcquireMemory(hmem, &mem_buffer, &size_in_bytes);
+		byte_string = rb_str_new((char *)mem_buffer, size_in_bytes);
+		FreeImage_CloseMemory(hmem);
+
+		return byte_string;
+	}
+
+	return Qnil;
+}
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+  void Init_extension() {
+    VALUE c = rb_cObject;
+    c = rb_const_get(c, rb_intern("ImageScience"));
+
+    rb_define_method(c, "height", (VALUE(*)(ANYARGS))height, 0);
+    rb_define_method(c, "resize", (VALUE(*)(ANYARGS))resize, 2);
+    rb_define_method(c, "save", (VALUE(*)(ANYARGS))save, 1);
+		rb_define_method(c, "bytes", (VALUE(*)(ANYARGS))bytes, 0);
+    rb_define_method(c, "width", (VALUE(*)(ANYARGS))width, 0);
+    rb_define_method(c, "with_crop", (VALUE(*)(ANYARGS))with_crop, 4);
+    rb_define_singleton_method(c, "with_image", (VALUE(*)(ANYARGS))with_image, 1);
+    rb_define_singleton_method(c, "with_image_from_memory", (VALUE(*)(ANYARGS))with_image_from_memory, 1);
+    FreeImage_SetOutputMessage(FreeImageMessageHandler);
+
+  }
+#ifdef __cplusplus
+}
+#endif

data/image_science.gemspec

@@ -0,0 +1,28 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "image_science/version"
+
+Gem::Specification.new do |s|
+  s.name = "jemmyw-image_science"
+  s.version = ImageScience::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ['Ryan Davis', 'Craig Buchek']
+  s.email = ['craig.buchek@asolutions.com']
+  s.homepage = "http://github.com/asynchrony/#{s.name}"
+  s.summary = %q{Replacement for RMagick; uses FreeImage instead of ImageMagick}
+  s.description = %q{ImageScience is a clean and happy Ruby library that generates
+thumbnails -- and kicks the living crap out of RMagick. Oh, and it
+doesn't leak memory like a sieve. :)
+
+This fork does not require RubyInline.
+
+For more information (on the original variant), see http://seattlerb.rubyforge.org/ImageScience.html
+}
+
+  s.rubyforge_project = "image_science"
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.extensions = `git ls-files -- ext/*/*.rb`.split("\n")
+  s.require_paths = ["lib"]
+end

data/lib/image_science/image_science.rb

@@ -0,0 +1,83 @@
+##
+# Provides a clean and simple API to generate thumbnails using
+# FreeImage as the underlying mechanism.
+#
+# For more information or if you have build issues with FreeImage, see
+# http://seattlerb.rubyforge.org/ImageScience.html
+
+class ImageScience
+
+  ##
+  # The top-level image loader opens +path+ and then yields the image.
+
+  def self.with_image(path) # :yields: image
+  end
+
+  ##
+  # The top-level image loader, opens an image from the string +data+ and then yields the image.
+
+  def self.with_image_from_memory(data) # :yields: image
+  end
+
+  ##
+  # Crops an image to +left+, +top+, +right+, and +bottom+ and then
+  # yields the new image.
+
+  def with_crop(left, top, right, bottom) # :yields: image
+  end
+
+  ##
+  # Returns the width of the image, in pixels.
+
+  def width; end
+
+  ##
+  # Returns the height of the image, in pixels.
+
+  def height; end
+
+  ##
+  # Saves the image out to +path+. Changing the file extension will
+  # convert the file type to the appropriate format.
+
+  def save(path); end
+
+  ##
+  # Resizes the image to +width+ and +height+ using a cubic-bspline
+  # filter and yields the new image.
+
+  def resize(width, height) # :yields: image
+  end
+
+  ##
+  # Creates a proportional thumbnail of the image scaled so its longest
+  # edge is resized to +size+ and yields the new image.
+
+  def thumbnail(size) # :yields: image
+    w, h = width, height
+    scale = size.to_f / (w > h ? w : h)
+
+    self.resize((w * scale).round, (h * scale).round) do |image|
+      yield image
+    end
+  end
+
+  ##
+  # Creates a square thumbnail of the image cropping the longest edge
+  # to match the shortest edge, resizes to +size+, and yields the new
+  # image.
+
+  def cropped_thumbnail(size) # :yields: image
+    w, h = width, height
+    l, t, r, b, half = 0, 0, w, h, (w - h).abs / 2
+
+    l, r = half, half + h if w > h
+    t, b = half, half + w if h > w
+
+    with_crop(l, t, r, b) do |img|
+      img.thumbnail(size) do |thumb|
+        yield thumb
+      end
+    end
+  end
+end

data/lib/image_science/version.rb

@@ -0,0 +1,3 @@
+class ImageScience
+  VERSION = '1.3.2.1.Asynchrony'
+end

data/lib/image_science.rb

@@ -0,0 +1,3 @@
+require 'image_science/version'
+require 'image_science/image_science'
+require 'image_science/extension'

data/test/test_image_science.rb

@@ -0,0 +1,191 @@
+dir = File.expand_path "~/.ruby_inline"
+if test ?d, dir then
+  require 'fileutils'
+  puts "nuking #{dir}"
+  # force removal, Windoze is bitching at me, something to hunt later...
+  FileUtils.rm_r dir, :force => true
+end
+
+require 'rubygems'
+require 'minitest/unit'
+require 'minitest/autorun' if $0 == __FILE__
+require 'image_science'
+
+class TestImageScience < MiniTest::Unit::TestCase
+  def setup
+    @path = 'test/pix.png'
+    @tmppath = 'test/pix-tmp.png'
+    @h = @w = 50
+  end
+
+  def teardown
+    File.unlink @tmppath if File.exist? @tmppath
+  end
+
+  def test_class_with_image
+    ImageScience.with_image @path do |img|
+      assert_kind_of ImageScience, img
+      assert_equal @h, img.height
+      assert_equal @w, img.width
+      assert img.save(@tmppath)
+    end
+
+    assert File.exists?(@tmppath)
+
+    ImageScience.with_image @tmppath do |img|
+      assert_kind_of ImageScience, img
+      assert_equal @h, img.height
+      assert_equal @w, img.width
+    end
+  end
+
+  def test_class_with_image_missing
+    assert_raises TypeError do
+      ImageScience.with_image @path + "nope" do |img|
+        flunk
+      end
+    end
+  end
+
+  def test_class_with_image_missing_with_img_extension
+    assert_raises RuntimeError do
+      assert_nil ImageScience.with_image("nope#{@path}") do |img|
+        flunk
+      end
+    end
+  end
+
+  def test_class_with_image_from_memory
+    data = File.new(@path).binmode.read
+
+    ImageScience.with_image_from_memory data do |img|
+      assert_kind_of ImageScience, img
+      assert_equal @h, img.height
+      assert_equal @w, img.width
+      assert img.save(@tmppath)
+    end
+
+    assert File.exists?(@tmppath)
+
+    ImageScience.with_image @tmppath do |img|
+      assert_kind_of ImageScience, img
+      assert_equal @h, img.height
+      assert_equal @w, img.width
+    end
+  end
+
+  def test_class_with_image_from_memory_empty_string
+    assert_raises TypeError do
+      ImageScience.with_image_from_memory "" do |img|
+        flunk
+      end
+    end
+  end
+
+  def test_bytes
+    data = File.new(@path).binmode.read
+
+    ImageScience.with_image_from_memory data do |img|
+      File.open(@tmppath, "wb"){|f| f.write img.bytes}
+      assert File.size(@tmppath) > 1100
+
+      ImageScience.with_image(@tmppath) do |img2|
+        assert_equal(img2.width, img.width)
+        assert_equal(img2.height, img.height)
+      end
+    end
+  end
+
+  def test_resize
+    ImageScience.with_image @path do |img|
+      img.resize(25, 25) do |thumb|
+        assert thumb.save(@tmppath)
+      end
+    end
+
+    assert File.exists?(@tmppath)
+
+    ImageScience.with_image @tmppath do |img|
+      assert_kind_of ImageScience, img
+      assert_equal 25, img.height
+      assert_equal 25, img.width
+    end
+  end
+
+  def test_resize_floats
+    ImageScience.with_image @path do |img|
+      img.resize(25.2, 25.7) do |thumb|
+        assert thumb.save(@tmppath)
+      end
+    end
+
+    assert File.exists?(@tmppath)
+
+    ImageScience.with_image @tmppath do |img|
+      assert_kind_of ImageScience, img
+      assert_equal 25, img.height
+      assert_equal 25, img.width
+    end
+  end
+
+  def test_resize_zero
+    assert_raises ArgumentError do
+      ImageScience.with_image @path do |img|
+        img.resize(0, 25) do |thumb|
+          assert thumb.save(@tmppath)
+        end
+      end
+    end
+
+    refute File.exists?(@tmppath)
+
+    assert_raises ArgumentError do
+      ImageScience.with_image @path do |img|
+        img.resize(25, 0) do |thumb|
+          assert thumb.save(@tmppath)
+        end
+      end
+    end
+
+    refute File.exists?(@tmppath)
+  end
+
+  def test_resize_negative
+    assert_raises ArgumentError do
+      ImageScience.with_image @path do |img|
+        img.resize(-25, 25) do |thumb|
+          assert thumb.save(@tmppath)
+        end
+      end
+    end
+
+    refute File.exists?(@tmppath)
+
+    assert_raises ArgumentError do
+      ImageScience.with_image @path do |img|
+        img.resize(25, -25) do |thumb|
+          assert thumb.save(@tmppath)
+        end
+      end
+    end
+
+    refute File.exists?(@tmppath)
+  end
+
+  def test_thumbnail
+    ImageScience.with_image @path do |img|
+      img.thumbnail(29) do |thumb|
+        assert thumb.save(@tmppath)
+      end
+    end
+
+    assert File.exists?(@tmppath)
+
+    ImageScience.with_image @tmppath do |img|
+      assert_kind_of ImageScience, img
+      assert_equal 29, img.height
+      assert_equal 29, img.width
+    end
+  end
+
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: jemmyw-image_science
+version: !ruby/object:Gem::Version
+  version: 1.3.2.1.Asynchrony
+  prerelease: 8
+platform: ruby
+authors:
+- Ryan Davis
+- Craig Buchek
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-13 00:00:00.000000000 Z
+dependencies: []
+description: ! 'ImageScience is a clean and happy Ruby library that generates
+
+  thumbnails -- and kicks the living crap out of RMagick. Oh, and it
+
+  doesn''t leak memory like a sieve. :)
+
+
+  This fork does not require RubyInline.
+
+
+  For more information (on the original variant), see http://seattlerb.rubyforge.org/ImageScience.html
+
+'
+email:
+- craig.buchek@asolutions.com
+executables:
+- image_science_thumb
+extensions:
+- ext/image_science/extconf.rb
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bench.rb
+- bin/image_science_thumb
+- ext/image_science/extconf.rb
+- ext/image_science/image_science.c
+- image_science.gemspec
+- lib/image_science.rb
+- lib/image_science/image_science.rb
+- lib/image_science/version.rb
+- test/pix.png
+- test/test_image_science.rb
+homepage: http://github.com/asynchrony/jemmyw-image_science
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: image_science
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Replacement for RMagick; uses FreeImage instead of ImageMagick
+test_files:
+- test/pix.png
+- test/test_image_science.rb