fastimage_resize 1.2.4 → 2.0.0

data/README

@@ -11,11 +11,11 @@ FastImage Resize is an extremely light solution for resizing images in ruby by u
 
 RubyInline
 
-  sudo gem install RubyInline
+  gem install RubyInline
 
 FastImage
 
-  sudo gem install sdsykes-fastimage -s http://gems.github.com
+  gem install fastimage
 
 Libgd
 

data/README.textile

@@ -10,18 +10,34 @@ And it doesn't rely on installing external heavy libraries such as RMagick (whic
 
 FastImage Resize uses *Libgd*, which is commonly available on most unix platforms, including OSX.  It is very likely that you already have this software installed on your server.
 
+As its input, FastImage Resize can take a URI, a filename, or an IO object (or anything that responds to :read).
+If you do not supply an output filename in the :outfile option, FastImage Resize will return you a Tempfile object. This will be unlinked when it is finalized during garbage collection.
+
+FastImage Resize relies on "RubyInline":https://github.com/seattlerb/rubyinline for compiling and managing the C extension code.
+
+h4. Incompatible API change Version 2.0.0 and above
+
+Note that the parameters for version 2.0.0 have changed, the output filename is no longer the second parameter. See the examples.
+
 h2. Examples
 
 <pre>
 <code>
   require 'fastimage_resize'
 
-  FastImage.resize("http://stephensykes.com/images/ss.com_x.gif", "my.gif", 100, 20)
-  => 1
-</pre>
-</code>
+  FastImage.resize("http://stephensykes.com/images/ss.com_x.gif", 100, 20, :outfile=>"my.gif")
+  => nil
 
-The file my.gif is created locally, containing the resized image.
+  outfile = FastImage.resize("nonexistentfile.png", 50, 50)
+  =>FastImage::ImageFetchFailure: FastImage::ImageFetchFailure
+
+  outfile = FastImage.resize("afile.png", 50, 150)
+  => #<File:/var/folders/vm/vd65y2597xl_by6c73_m9j1h0000gn/T/FastImage20111003-7638-x3l8r7-0>
+  
+  File.open("afile.png", "r") {|f| FastImage.resize(f, 100, 100)}
+  => #<File:/var/folders/vm/vd65y2597xl_by6c73_m9j1h0000gn/T/FastImage20111003-7638-y1ofh-0>
+</code>
+</pre>
 
 h2. Installation
 
@@ -31,7 +47,7 @@ h4. Gem
 
 <pre>
 <code>
-  sudo gem install fastimage_resize
+  gem install fastimage_resize
 </pre>
 </code>
 
@@ -74,7 +90,7 @@ h2. Requirements
 
 <pre>
 <code>
-  sudo gem install RubyInline
+  gem install RubyInline
 </pre>
 </code>
 
@@ -82,7 +98,7 @@ h2. Requirements
 
 <pre>
 <code>
-  sudo gem install fastimage
+  gem install fastimage
 </pre>
 </code>
 
@@ -113,8 +129,16 @@ Because of the way that libgd works, gif files that have transparency may not al
 
 h2. Tests
 
-You'll need to 'sudo gem install fakeweb' to be able to run the tests
+You'll need to 'gem install fakeweb' to be able to run the tests
 
 h2. References
 
 * "http://blog.new-bamboo.co.uk/2007/12/3/super-f-simple-resizing":http://blog.new-bamboo.co.uk/2007/12/3/super-f-simple-resizing
+
+h2. Licence
+
+MIT, see file MIT_LICENCE
+
+h2. Author
+
+Stephen Sykes, @sdsykes

data/VERSION.yml

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

data/lib/fastimage_resize.rb

@@ -4,18 +4,18 @@
 #
 #   require 'fastimage_resize'
 #
-#   FastImage.resize("http://stephensykes.com/images/ss.com_x.gif", "my.gif", 100, 20)
+#   FastImage.resize("http://stephensykes.com/images/ss.com_x.gif", 100, 20, :outfile=>"my.gif")
 #   => 1
 #
 # === Requirements
 #
 # RubyInline
 #
-#   sudo gem install RubyInline
+#   gem install RubyInline
 #
 # FastImage
 #
-#   sudo gem install sdsykes-fastimage -s http://gems.github.com
+#   gem install fastimage
 #
 # Libgd
 #
@@ -37,28 +37,73 @@ class FastImage
   class FormatNotSupported < FastImageException # :nodoc:
   end
   
-  def self.resize(uri_in, file_out, w, h, options={})
-    jpeg_quality = options[:jpeg_quality] || -1
+  # Resizes an image, storing the result in a file given in file_out
+  #
+  # Input can be a filename, a uri, or an IO object.
+  #
+  # FastImage Resize can resize GIF, JPEG and PNG files.
+  #
+  # === Example
+  #
+  #   require 'fastimage_resize'
+  #
+  #   FastImage.resize("http://stephensykes.com/images/ss.com_x.gif", 100, 20, :outfile=>"my.gif")
+  #
+  # === Supported options
+  # [:jpeg_quality]
+  #   A figure passed to libgd to determine quality of output jpeg (only useful if input is jpeg)
+  # [:outfile]
+  #   Name of a file to store the output in, in this case a temp file is not used
+  #
+  def self.resize(input, w, h, options={})
+    jpeg_quality = options[:jpeg_quality].to_i || -1
+    file_out = options[:outfile]
     
-    u = URI.parse(uri_in)
-    if u.scheme == "http" || u.scheme == "https" || u.scheme == "ftp"
-      f = Tempfile.new(name)
-      f.write(open(u).read)
-      f.close
-      resize_local(f.path, file_out, w, h, jpeg_quality)
-      File.unlink(f.path)
+    if input.respond_to?(:read)
+      file_in = read_to_local(input)
     else
-      resize_local(uri_in, file_out, w, h, jpeg_quality)
+      u = URI.parse(input)
+      if u.scheme == "http" || u.scheme == "https" || u.scheme == "ftp"
+        file_in = read_to_local(open(u))
+      else
+        file_in = input.to_s
+      end
     end
+
+    if !file_out
+      temp_file = Tempfile.new(name)
+      file_out = temp_file.path
+    else
+      temp_file = nil
+    end
+
+    fast_image = new(file_in, :raise_on_failure=>true)
+    type_index = SUPPORTED_FORMATS.index(fast_image.type)
+    raise FormatNotSupported unless type_index
+
+    in_path = file_in.respond_to?(:path) ? file_in.path : file_in
+    
+    fast_image.resize_image(in_path, file_out.to_s, w.to_i, h.to_i, type_index, jpeg_quality)
+
+    if file_in.respond_to?(:close)
+      file_in.close
+      file_in.unlink
+    end
+
+    temp_file
   rescue OpenURI::HTTPError, SocketError, URI::InvalidURIError, RuntimeError => e
     raise ImageFetchFailure, e.class
   end
 
-  def self.resize_local(file_in, file_out, w, h, jpeg_quality)
-    fi = new(file_in, :raise_on_failure=>true)
-    type_index = SUPPORTED_FORMATS.index(fi.type)
-    raise FormatNotSupported unless type_index
-    fi.resize_image(file_in, file_out, w.to_i, h.to_i, type_index, jpeg_quality)
+  private
+
+  # returns readable tempfile
+  def self.read_to_local(readable)
+    temp = Tempfile.new(name)
+    temp.write(readable.read)
+    temp.close
+    temp.open
+    temp
   end
 
   def resize_image(filename_in, filename_out, w, h, image_type, jpeg_quality); end

data/test/test.rb

@@ -41,20 +41,49 @@ END
 FakeWeb.register_uri(:get, "#{TestUrl}/redirect", :response=>redirect_response)
 
 class FastImageResizeTest < Test::Unit::TestCase
-  def test_resize_image_types
+  def test_resize_image_types_from_http
     GoodFixtures.each do |fn, info|
       outfile = File.join(PathHere, "fixtures", "resized_" + fn)
-      FastImage.resize(TestUrl + fn, outfile, info[1][0] / 3, info[1][1] / 2)
+      FastImage.resize(TestUrl + fn, info[1][0] / 3, info[1][1] / 2, :outfile=>outfile)
       assert_equal [info[1][0] / 3, info[1][1] / 2], FastImage.size(outfile)
       File.unlink outfile
     end
   end
 
+  def test_resize_image_types_from_files
+    GoodFixtures.each do |fn, info|
+      outfile = File.join(PathHere, "fixtures", "resized_" + fn)
+      FastImage.resize(File.join(FixturePath, fn), info[1][0] / 3, info[1][1] / 2, :outfile=>outfile)
+      assert_equal [info[1][0] / 3, info[1][1] / 2], FastImage.size(outfile)
+      File.unlink outfile
+    end
+  end
+
+  def test_resize_image_types_from_io_objects
+    GoodFixtures.each do |fn, info|
+      outfile = File.join(PathHere, "fixtures", "resized_" + fn)
+      File.open(File.join(FixturePath, fn)) do |io|
+        FastImage.resize(io, info[1][0] / 3, info[1][1] / 2, :outfile=>outfile)
+        assert_equal [info[1][0] / 3, info[1][1] / 2], FastImage.size(outfile)
+        File.unlink outfile
+      end
+    end
+  end
+
+  def test_resize_to_temp_file
+    GoodFixtures.each do |fn, info|
+      File.open(File.join(FixturePath, fn)) do |io|
+        outfile = FastImage.resize(io, info[1][0] / 3, info[1][1] / 2)
+        assert_equal [info[1][0] / 3, info[1][1] / 2], FastImage.size(outfile)
+      end
+    end
+  end
+
   def test_should_raise_for_bmp_files
     fn = BadFixtures[0]
     outfile = File.join(PathHere, "fixtures", "resized_" + fn)
     assert_raises(FastImage::FormatNotSupported) do
-      FastImage.resize(TestUrl + fn, outfile, 20, 20)
+      FastImage.resize(TestUrl + fn, 20, 20, :outfile=>outfile)
     end
   end
   
@@ -62,7 +91,7 @@ class FastImageResizeTest < Test::Unit::TestCase
     fn = BadFixtures[1]
     outfile = File.join(PathHere, "fixtures", "resized_" + fn)
     assert_raises(FastImage::SizeNotFound) do
-      FastImage.resize(TestUrl + fn, outfile, 20, 20)
+      FastImage.resize(TestUrl + fn, 20, 20, :outfile=>outfile)
     end
   end
   
@@ -70,19 +99,19 @@ class FastImageResizeTest < Test::Unit::TestCase
     fn = BadFixtures[2]
     outfile = File.join(PathHere, "fixtures", "resized_" + fn)
     assert_raises(FastImage::UnknownImageType) do
-      FastImage.resize(TestUrl + fn, outfile, 20, 20)
+      FastImage.resize(TestUrl + fn, 20, 20, :outfile=>outfile)
     end
   end
   
   def test_should_raise_for_invalid_uri
     assert_raises(FastImage::ImageFetchFailure) do
-      FastImage.resize("#{TestUrl}////%&redirect", "foo", 20, 20)
+      FastImage.resize("#{TestUrl}////%&redirect", 20, 20)
     end
   end
   
   def test_should_raise_for_redirect
     assert_raises(FastImage::ImageFetchFailure) do
-      FastImage.resize("#{TestUrl}/redirect", "foo", 20, 20)
+      FastImage.resize("#{TestUrl}/redirect", 20, 20)
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: fastimage_resize
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 15
   prerelease: false
   segments: 
-  - 1
   - 2
-  - 4
-  version: 1.2.4
+  - 0
+  - 0
+  version: 2.0.0
 platform: ruby
 authors: 
 - Stephen Sykes
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-27 00:00:00 +03:00
+date: 2011-10-03 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -42,12 +42,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 31
+        hash: 13
         segments: 
         - 1
         - 2
-        - 0
-        version: 1.2.0
+        - 9
+        version: 1.2.9
   type: :runtime
   version_requirements: *id002
 description: FastImage Resize is an extremely light solution for resizing images in ruby by using libgd.