sdsykes-fastimage 1.0.2 → 1.1.0

data/README.textile

@@ -14,6 +14,8 @@ FastImage does this minimal fetch for image types GIF, JPEG, PNG and BMP.  And i
 
 You only need supply the uri, and FastImage will do the rest.
 
+Fastimage can also read local (and other) files, and uses the open-uri library to do so.
+
 h2. Examples
 
 <pre>
@@ -24,6 +26,8 @@ FastImage.size("http://stephensykes.com/images/ss.com_x.gif")
 => [266, 56]  # width, height
 FastImage.type("http://stephensykes.com/images/pngimage")
 => :png
+FastImage.type("/some/local/file.gif")
+=> :gif
 </code>
 </pre>
 
@@ -62,10 +66,10 @@ You'll need to 'sudo gem install fakeweb' to be able to run the tests.
 ruby test/test.rb
 Loaded suite test/test
 Started
-.........
-Finished in 0.055059 seconds.
+...............
+Finished in 0.059392 seconds.
 
-9 tests, 15 assertions, 0 failures, 0 errors
+15 tests, 27 assertions, 0 failures, 0 errors
 </code>
 </pre>
 

data/VERSION.yml

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

data/lib/fastimage.rb

@@ -8,6 +8,11 @@
 #
 # FastImage knows about GIF, JPEG, BMP and PNG files.
 #
+# FastImage can also read files from the local filesystem by supplying the path instead of a uri.
+# In this case FastImage uses the open-uri library to read the file in chunks of 256 bytes until
+# it has enough. This is possibly a useful bandwidth-saving feature if the file is on a network
+# attached disk rather than truly local.
+#
 # === Examples
 #   require 'fastimage'
 #
@@ -15,6 +20,8 @@
 #   => [266, 56]
 #   FastImage.type("http://stephensykes.com/images/pngimage")
 #   => :png
+#   FastImage.type("/some/local/file.gif")
+#   => :gif
 #
 # === References
 # * http://snippets.dzone.com/posts/show/805
@@ -23,6 +30,7 @@
 # * http://imagesize.rubyforge.org/
 #
 require 'net/https'
+require 'open-uri'
 
 class FastImage
   attr_reader :size, :type
@@ -39,11 +47,13 @@ class FastImage
   end
 
   DefaultTimeout = 2
+  
+  LocalFileChunkSize = 256
 
   # Returns an array containing the width and height of the image.
   # It will return nil if the image could not be fetched, or if the image type was not recognised.
   #
-  # By default there is a timeout of 2 seconds for opening and reading from the remote server.
+  # By default there is a timeout of 2 seconds for opening and reading from a remote server.
   # This can be changed by passing a :timeout => number_of_seconds in the options.
   #
   # If you wish FastImage to raise if it cannot size the image for any reason, then pass
@@ -63,6 +73,8 @@ class FastImage
   #   => [500, 375]
   #   FastImage.size("http://www-ece.rice.edu/~wakin/images/lena512.bmp")
   #   => [512, 512]
+  #   FastImage.size("test/fixtures/test.jpg")
+  #   => [882, 470]
   #   FastImage.size("http://pennysmalls.com/does_not_exist")
   #   => nil
   #   FastImage.size("http://pennysmalls.com/does_not_exist", :raise_on_failure=>true)
@@ -87,7 +99,7 @@ class FastImage
   # Returns an symbol indicating the image type fetched from a uri.
   # It will return nil if the image could not be fetched, or if the image type was not recognised.
   #
-  # By default there is a timeout of 2 seconds for opening and reading from the remote server.
+  # By default there is a timeout of 2 seconds for opening and reading from a remote server.
   # This can be changed by passing a :timeout => number_of_seconds in the options.
   #
   # If you wish FastImage to raise if it cannot find the type of the image for any reason, then pass
@@ -105,6 +117,8 @@ class FastImage
   #   => :jpg
   #   FastImage.type("http://www-ece.rice.edu/~wakin/images/lena512.bmp")
   #   => :bmp
+  #   FastImage.type("test/fixtures/test.jpg")
+  #   => :jpg
   #   FastImage.type("http://pennysmalls.com/does_not_exist")
   #   => nil
   #
@@ -119,52 +133,65 @@ class FastImage
   end
 
   def initialize(uri, options={})
-    @type_only = options[:type_only]
-    setup_http(uri, options)
-    @http.request_get(@http_get_path) do |res|
-      raise ImageFetchFailure unless res.is_a?(Net::HTTPSuccess)
-      fetch_size_from_response(res)
+    @property = options[:type_only] ? :type : :size
+    @timeout = options[:timeout] || DefaultTimeout
+    @uri = uri
+    @parsed_uri = URI.parse(uri)
+    if @parsed_uri.scheme == "http" || @parsed_uri.scheme == "https"
+      fetch_using_http
+    else
+      fetch_using_open_uri
     end
-    raise SizeNotFound if options[:raise_on_failure] && !@size
+    raise SizeNotFound if options[:raise_on_failure] && !@type_only && !@size
   rescue Timeout::Error, SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ECONNRESET, ImageFetchFailure
     raise ImageFetchFailure if options[:raise_on_failure]
+  rescue Errno::ENOENT
+    raise ImageFetchFailure if options[:raise_on_failure]    
   rescue UnknownImageType
     raise UnknownImageType if options[:raise_on_failure]
   end
 
   private
 
-  def setup_http(uri, options)
-    u = URI.parse(uri)
-    @http = Net::HTTP.new(u.host, u.port)
-    @http.use_ssl = (u.scheme == "https")
-    @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-    @http.open_timeout = options[:timeout] || DefaultTimeout
-    @http.read_timeout = options[:timeout] || DefaultTimeout
-    @http_get_path = u.request_uri
+  def fetch_using_http
+    setup_http
+    @http.request_get(@parsed_uri.request_uri) do |res|
+      raise ImageFetchFailure unless res.is_a?(Net::HTTPSuccess)
+      res.read_body do |str|
+        break if parse_packet(str)
+      end
+    end
   end
 
-  def fetch_type_from_response(res)
-    fetch_from_response(res, :type){parse_type}
+  def setup_http
+    @http = Net::HTTP.new(@parsed_uri.host, @parsed_uri.port)
+    @http.use_ssl = (@parsed_uri.scheme == "https")
+    @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    @http.open_timeout = @timeout
+    @http.read_timeout = @timeout
   end
 
-  def fetch_size_from_response(res)
-    fetch_from_response(res, :size){parse_size}
+  def fetch_using_open_uri
+    open(@uri) do |s|
+      while str = s.read(LocalFileChunkSize)
+        break if parse_packet(str)
+      end
+    end
   end
 
-  def fetch_from_response(res, item)
-    @unused_str = ""
-    res.read_body do |str|
-      @str = @unused_str + str
-      @strpos = 0
-      begin
-        result = yield
-        if result 
-          instance_variable_set("@#{item}", result)
-          break
-        end
-      rescue MoreCharsNeeded
+  # returns true once result is achieved
+  #
+  def parse_packet(str)
+    @str = (@unused_str || "") + str
+    @strpos = 0
+    begin
+      result = send("parse_#{@property}")
+      if result 
+        instance_variable_set("@#{@property}", result)
+        true
       end
+    rescue MoreCharsNeeded
+      false
     end
   end
 

data/test/test.rb

@@ -2,11 +2,13 @@ require 'rubygems'
 
 require 'test/unit'
 
-require 'fastimage'
+PathHere = File.dirname(__FILE__)
+
+require File.join(PathHere, "..", "lib", 'fastimage')
 
 require 'fakeweb'
 
-FixturePath = File.join(File.dirname(__FILE__), "fixtures")
+FixturePath = File.join(PathHere, "fixtures")
 
 GoodFixtures = {
   "test.bmp"=>[:bmp, [40, 27]],
@@ -75,4 +77,34 @@ class FasImageTest < Test::Unit::TestCase
       FastImage.size(TestUrl + "test.ico", :raise_on_failure=>true)
     end
   end
+  
+  def test_should_report_type_correctly_for_local_files
+    GoodFixtures.each do |fn, info|
+      assert_equal info[0], FastImage.type(File.join(FixturePath, fn))
+    end    
+  end
+  
+  def test_should_report_size_correctly_for_local_files
+    GoodFixtures.each do |fn, info|
+      assert_equal info[1], FastImage.size(File.join(FixturePath, fn))
+    end    
+  end
+  
+  def test_should_return_nil_on_fetch_failure_for_local_path
+    assert_nil FastImage.size("does_not_exist")
+  end
+  
+  def test_should_return_nil_for_faulty_jpeg_where_size_cannot_be_found_for_local_file
+    assert_nil FastImage.size(File.join(FixturePath, "faulty.jpg"))
+  end
+
+  def test_should_return_nil_when_image_type_not_known_for_local_file
+    assert_nil FastImage.size(File.join(FixturePath, "test.ico"))
+  end
+  
+  def test_should_raise_when_asked_to_when_size_cannot_be_found_for_local_file
+    assert_raises(FastImage::SizeNotFound) do
+      FastImage.size(File.join(FixturePath, "faulty.jpg"), :raise_on_failure=>true)
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sdsykes-fastimage
 version: !ruby/object:Gem::Version 
-  version: 1.0.2
+  version: 1.1.0
 platform: ruby
 authors: 
 - Stephen Sykes