has_image 0.2.3 → 0.3.0

data/lib/has_image/processor.rb

@@ -9,24 +9,32 @@ module HasImage
     
     class << self
       
-      # "The form of an {extended geometry
-      # string}[http://www.imagemagick.org/script/command-line-options.php?#resize] is
-      # <width>x<height>{+-}<xoffset>{+-}<yoffset>{%}{!}{<}{>}"
+      # The form of an {extended geometry string}[http://www.imagemagick.org/script/command-line-options.php?#resize] is:
+      #
+      #   <width>x<height>{+-}<xoffset>{+-}<yoffset>{%}{!}{<}{>}
       def geometry_string_valid?(string)
         string =~ /\A[\d]*x[\d]*([+-][0-9][+-][0-9])?[%@!<>^]?\Z/
       end
       
-      # Arg should be either a file, or a path. This runs ImageMagick's
-      # "identify" command and looks for an exit status indicating an error. If
-      # there is no error, then ImageMagick has identified the file as something
-      # it can work with and it will be converted to the desired output format.
+      # Arg should be either a file or a path. This runs ImageMagick's
+      # "identify" command and looks for an exit status indicating an error.
+      # If there is no error, then ImageMagick has identified the file as
+      # something it can work with and it will be converted to the desired
+      # output format.
+      #
+      # Note that this is used in place of any mimetype checks. HasImage
+      # assumes that is ImageMagick is able to process the file, then it's OK.
+      # Since ImageMagick can be compiled with many different options for
+      # supporting various file types (or not) this is safer and more complete
+      # than checking the mime type.
       def valid?(arg)
         arg.close if arg.respond_to?(:close) && !arg.closed?
         silence_stderr do
           `identify #{arg.respond_to?(:path) ? arg.path : arg.to_s}`
           $? == 0
         end
-      end    
+      end
+      
     end
 
     # The constuctor should be invoked with the options set by has_image.
@@ -34,25 +42,47 @@ module HasImage
       @options = options
     end
     
-    # Create the resized image, and transforms it to the desired output
-    # format if necessary. The size should be a valid ImageMagick {geometry
-    # string}[http://www.imagemagick.org/script/command-line-options.php#resize].
-    def resize(file, size)
-      unless Processor.geometry_string_valid?(size)
+    # Creates the resized image, and transforms it to the desired output
+    # format if necessary. 
+    # 
+    # +size+ should be a valid ImageMagick {geometry string}[http://www.imagemagick.org/script/command-line-options.php#resize].
+    # +format+ should be an image format supported by ImageMagick, e.g. "PNG", "JPEG"
+    # If a block is given, it yields the processed image file as a file-like object using IO#read.
+    def process(file, size = options[:resize_to], format = options[:convert_to])
+      unless size.blank? || Processor.geometry_string_valid?(size)
         raise InvalidGeometryError.new('"%s" is not a valid ImageMagick geometry string' % size)
       end
-      silence_stderr do
-        path = file.respond_to?(:path) ? file.path : file
-        file.close if file.respond_to?(:close) && !file.closed?
-        @image = MiniMagick::Image.from_file(path)
-        convert_image
-        resize_image(size)   
-        return @image
+      with_image(file) do |image|
+        convert_image(image, format) if format
+        resize_image(image, size) if size
+        yield IO.read(image.path) if block_given?
+        image
       end
-    rescue MiniMagick::MiniMagickError
-      raise ProcessorError.new("That doesn't look like an image file.")
     end
+    alias_method :resize, :process #Backwards-compat
     
+    # Gets the given +dimension+ (width/height) from the image file at +path+.
+    def measure(path, dimension)
+      MiniMagick::Image.from_file(path)[dimension.to_sym]
+    end
+    
+  private
+    # Operates on the image with MiniMagick. Yields a MiniMagick::Image object.
+    def with_image(file)
+      path = file.respond_to?(:path) ? file.path : file
+      file.close if file.respond_to?(:close) && !file.closed?
+      silence_stderr do
+        begin
+          image = MiniMagick::Image.from_file(path)
+          yield image
+        rescue MiniMagick::MiniMagickError
+          raise ProcessorError.new("#{path} doesn't look like an image file.")
+        ensure
+          image.tempfile.close! if defined?(image) && image
+        end
+      end
+    end
+  
     # Image resizing is placed in a separate method for easy monkey-patching.
     # This is intended to be invoked from resize, rather than directly.
     # By default, the following ImageMagick functionality is invoked:
@@ -62,8 +92,10 @@ module HasImage
     # * gravity[http://www.imagemagick.org/script/command-line-options.php#gravity]
     # * extent[http://www.imagemagick.org/script/command-line-options.php#extent]
     # * quality[http://www.imagemagick.org/script/command-line-options.php#quality]
-    def resize_image(size)
-      @image.combine_options do |commands|
+    #
+    # +image+ should be a MiniMagick::Image. +size+ should be a geometry string.
+    def resize_image(image, size)
+      image.combine_options do |commands|
         commands.send("auto-orient".to_sym)
         commands.strip
         # Fixed-dimension images
@@ -79,13 +111,8 @@ module HasImage
       end
     end
 
-    private
-    
-    # This was placed in a separate method largely to facilitate debugging
-    # and profiling.
-    def convert_image
-      return if @image[:format] == options[:convert_to]
-      @image.format(options[:convert_to])
+    def convert_image(image, format=options[:convert_to])
+      image.format(format) unless image[:format] == format
     end
     
   end

data/lib/has_image/storage.rb

@@ -11,6 +11,8 @@ module HasImage
   # storage mechanism for Amazon AWS, Photobucket, DBFile, SFTP, or whatever
   # you want.  
   class Storage
+    class_inheritable_accessor :thumbnail_separator
+    write_inheritable_attribute :thumbnail_separator, '_'
     
     attr_accessor :image_data, :options, :temp_file
 
@@ -21,17 +23,29 @@ module HasImage
       # to this problem fails with high ids, such as those created by
       # db:fixture:load. This version scales to large ids more gracefully.
       # Thanks to Adrian Mugnolo for the fix.
+      #++
+      # FIXME: collides with IDs with more than 8 digits
+      #--
       def partitioned_path(id, *args)
         ["%04d" % ((id.to_i / 1e4) % 1e4), "%04d" % (id.to_i % 1e4)].concat(args)
       end
-
+      
+      def id_from_partitioned_path(partitioned_path)
+        partitioned_path.join.to_i
+      end
+      
+      def id_from_path(path)
+        path = path.split('/') if path.is_a?(String)
+        path_partitions = 2
+        id_from_partitioned_path(path.first(path_partitions))
+      end
+      
       # By default, simply accepts and returns the id of the object. This is
       # here to allow you to monkey patch this method, for example, if you
       # wish instead to generate and return a UUID.
       def generated_file_name(*args)
         return args.first.to_param.to_s
       end
-          
     end
 
     # The constuctor should be invoked with the options set by has_image.
@@ -49,7 +63,7 @@ module HasImage
       else
         image_data.rewind
         @temp_file = Tempfile.new 'has_image_data_%s' % Storage.generated_file_name
-        @temp_file.write(image_data.read)        
+        @temp_file.write(image_data.read)
       end
     end
 
@@ -65,24 +79,23 @@ module HasImage
       @temp_file.size > options[:max_size]
     end
     
-    # A tip of the hat to attachment_fu.
-    alias uploaded_data= image_data=
-    
-    # A tip of the hat to attachment_fu.
-    alias uploaded_data image_data
-    
     # Invokes the processor to resize the image(s) and the installs them to
     # the appropriate directory.
     def install_images(object)
       generated_name = Storage.generated_file_name(object)
       install_main_image(object.has_image_id, generated_name)
-      install_thumbnails(object.has_image_id, generated_name) if !options[:thumbnails].empty?
+      generate_thumbnails(object.has_image_id, generated_name) if thumbnails_needed?
       return generated_name
     ensure  
       @temp_file.close! if !@temp_file.closed?
       @temp_file = nil
     end
     
+    # Measures the given dimension using the processor
+    def measure(path, dimension)
+      processor.measure(path, dimension)
+    end
+    
     # Gets the "web" path for an image. For example:
     #
     #   /photos/0000/0001/3er0zs.jpg
@@ -108,10 +121,32 @@ module HasImage
       !(image_too_small? || image_too_big?)
     end
     
-    def regenerate_thumbnails(id, name)
-      install_thumbnails(id, name)
+    # Write the thumbnails to the install directory - probably somewhere under
+    # RAILS_ROOT/public.
+    def generate_thumbnails(id, name)
+      ensure_directory_exists!(id)
+      options[:thumbnails].keys.each { |thumb_name| generate_thumbnail(id, name, thumb_name) }
+    end
+    alias_method :regenerate_thumbnails, :generate_thumbnails #Backwards-compat
+    
+    def generate_thumbnail(id, name, thumb_name)
+      size_spec = options[:thumbnails][thumb_name.to_sym]
+      raise StorageError unless size_spec
+      ensure_directory_exists!(id)
+      File.open absolute_path(id, name, thumb_name), "w" do |thumbnail_destination|
+        processor.process absolute_path(id, name), size_spec do |thumbnail_data|
+          thumbnail_destination.write thumbnail_data
+        end
+      end
     end
-
+     
+    # Gets the full local filesystem path for an image. For example:
+    #
+    #   /var/sites/example.com/production/public/photos/0000/0001/3er0zs.jpg
+    def filesystem_path_for(object, thumbnail = nil)
+      File.join(path_for(object.has_image_id), file_name_for(object.send(options[:column]), thumbnail))
+    end
+    
     protected
 
     # Gets the extension to append to the image. Transforms "jpeg" to "jpg."
@@ -129,49 +164,42 @@ module HasImage
     #
     #   "abc123_thumb.jpg"
     #   
-    #
+    # It uses an underscore to separatore parts by default, but that is configurable
+    # by setting HasImage::Storage.thumbnail_separator
     def file_name_for(*args)
-      "%s.%s" % [args.compact.join("_"), extension]
+      "%s.%s" % [args.compact.join(self.class.thumbnail_separator), extension]
     end
 
-    # Gets the full local filesystem path for an image. For example:
+    # Get the full path for the id. For example:
     #
-    #   /var/sites/example.com/production/public/photos/0000/0001/3er0zs.jpg
-    def filesystem_path_for(object, thumbnail = nil)
-      File.join(path_for(object.has_image_id), file_name_for(object.has_image_file, thumbnail))
+    #  /var/sites/example.org/production/public/photos/0000/0001
+    def path_for(id)
+      debugger if $debug
+      File.join(options[:base_path], options[:path_prefix], Storage.partitioned_path(id))
     end
     
-    # Write the main image to the install directory - probably somewhere under
-    # RAILS_ROOT/public.
-    def install_main_image(id, name)
+    def absolute_path(id, *args)
+      File.join(path_for(id), file_name_for(*args))
+    end
+    
+    def ensure_directory_exists!(id)
       FileUtils.mkdir_p path_for(id)
-      main = processor.resize(@temp_file, @options[:resize_to])
-      file = File.open(File.join(path_for(id), file_name_for(name)), "w")
-      file.write(IO.read(main.path))
-      file.close
-      main.tempfile.close!
     end
     
-    # Write the thumbnails to the install directory - probably somewhere under
+    # Write the main image to the install directory - probably somewhere under
     # RAILS_ROOT/public.
-    def install_thumbnails(id, name)
-      FileUtils.mkdir_p path_for(id)
-      path = File.join(path_for(id), file_name_for(name))
-      options[:thumbnails].each do |thumb_name, size|
-        thumb = processor.resize(path, size)
-        thumb.tempfile.close
-        file = File.open(File.join(path_for(id), file_name_for(name, thumb_name)), "w")
-        file.write(IO.read(thumb.tempfile.path))
-        file.close
-        thumb.tempfile.close!
+    def install_main_image(id, name)
+      ensure_directory_exists!(id)
+      File.open absolute_path(id, name), "w" do |final_destination|
+        processor.process(@temp_file) do |processed_image|
+          final_destination.write processed_image
+        end
       end
     end
-
-    # Get the full path for the id. For example:
-    #
-    #  /var/sites/example.org/production/public/photos/0000/0001
-    def path_for(id)
-      File.join(options[:base_path], options[:path_prefix], Storage.partitioned_path(id))
+    
+    # used in #install_images
+    def thumbnails_needed?
+      !options[:thumbnails].empty? && options[:auto_generate_thumbnails]
     end
     
     # Instantiates the processor using the options set in my contructor (if
@@ -180,7 +208,6 @@ module HasImage
     def processor
       @processor ||= Processor.new(options)
     end
-    
   end
   
 end

data/test/storage_test.rb

@@ -11,7 +11,9 @@ class StorageTest < Test::Unit::TestCase
   end
   
   def default_options
-    HasImage.default_options_for("tests").merge(
+    mock_class = "test"
+    mock_class.stubs(:table_name).returns('tests')
+    HasImage.default_options_for(mock_class).merge(
       :base_path => File.join(File.dirname(__FILE__), '..', 'tmp')
     )
   end
@@ -23,6 +25,25 @@ class StorageTest < Test::Unit::TestCase
   def test_partitioned_path_doesnt_collide_with_high_ids
     assert_not_equal HasImage::Storage.partitioned_path(867792732),
       HasImage::Storage.partitioned_path(867792731)
+    # FIXME: collisions when IDs have more than 8 digits
+    # assert_not_equal HasImage::Storage.partitioned_path(967792731),
+    #   HasImage::Storage.partitioned_path(967792731)  
+  end
+  
+  def test_id_from_partitioned_path
+    assert_equal 123, HasImage::Storage.id_from_partitioned_path(HasImage::Storage.partitioned_path(123))
+    assert_equal 56, HasImage::Storage.id_from_partitioned_path(HasImage::Storage.partitioned_path(56))
+    assert_equal 67792732, HasImage::Storage.id_from_partitioned_path(HasImage::Storage.partitioned_path(67792732))
+    # FIXME: for IDs with more than 8 digits partitioned path is destructive
+    # assert_equal 867792731, HasImage::Storage.id_from_partitioned_path(HasImage::Storage.partitioned_path(867792731))
+  end
+  
+  def test_id_from_path_accepts_array
+    assert_equal 123, HasImage::Storage.id_from_path(['0000','0123','image_something.jpg'])
+  end
+  
+  def test_id_from_path_accepts_path
+    assert_equal 12345, HasImage::Storage.id_from_path('0001/2345/0123/image_something.jpg')
   end
   
   def test_generated_file_name
@@ -45,6 +66,17 @@ class StorageTest < Test::Unit::TestCase
     pic = stub(:has_image_file => "my+pic", :has_image_id => 1)
     assert_equal "/tests/0000/0001/my%2Bpic_square.jpg", @storage.public_path_for(pic, :square)
   end
+  
+  def test_name_generation_takes_into_account_thumbnail_separator_constant
+    old_separator = HasImage::Storage.thumbnail_separator
+    
+    @storage = HasImage::Storage.new(default_options.merge(:thumbnails => {:schick => '22x22'}, :base_path => '/public'))
+    HasImage::Storage.thumbnail_separator = '.'
+    pic = stub(:has_image_file => "pic", :has_image_id => 1)
+    assert_equal "/tests/0000/0001/pic.schick.jpg", @storage.public_path_for(pic, :schick)
+    
+    HasImage::Storage.thumbnail_separator = old_separator
+  end
 
   def test_escape_file_name_for_http
     @storage = HasImage::Storage.new(default_options.merge(:base_path => '/public'))
@@ -83,7 +115,17 @@ class StorageTest < Test::Unit::TestCase
       :one => "100x100", :two => "200x200"}))
     @storage.image_data = temp_file("image.jpg")
     @name = @storage.install_images(stub(:has_image_id => 1))
-    assert @storage.remove_images(stub(:has_image_id => 1), @name)    
+    assert @storage.remove_images(stub(:has_image_id => 1), @name)
+  end
+  
+  def test_install_images_doesnt_automatically_generate_thumbnails_if_that_option_is_set
+    @storage = HasImage::Storage.new(default_options.merge(
+      :thumbnails => {:two => "200x200"},
+      :auto_generate_thumbnails => false
+    ))
+    @storage.image_data = temp_file("image.jpg")
+    @storage.expects(:generate_thumbnails).never
+    @storage.install_images(stub(:has_image_id => 1))
   end
 
   def test_image_not_too_small

data/test_rails/complex_pic_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+class ComplexPic < ActiveRecord::Base
+  has_image
+end
+
+class ComplexPicTest < Test::Unit::TestCase
+  def setup
+    # Note: Be sure to not set the whole options hash in your tests below
+    ComplexPic.has_image_options = HasImage.default_options_for(ComplexPic)
+    ComplexPic.has_image_options[:column] = :filename
+    ComplexPic.has_image_options[:base_path] = File.join(RAILS_ROOT, 'tmp')
+    ComplexPic.has_image_options[:resize_to] = nil
+  end
+  
+  def teardown
+    FileUtils.rm_rf(File.join(RAILS_ROOT, 'tmp', 'complex_pics'))
+  end
+  
+  def test_should_save_width_to_db_on_create
+    @pic = ComplexPic.create!(:image_data => fixture_file_upload("/image.jpg", "image/jpeg"))
+    assert_equal 1916, @pic[:width]
+  end
+
+  def test_should_save_height_to_db_on_create
+    @pic = ComplexPic.create!(:image_data => fixture_file_upload("/image.jpg", "image/jpeg"))
+    assert_equal 1990, @pic[:height]
+  end
+  
+  def test_should_use_value_from_db_in_height_reader
+    @pic = ComplexPic.create!(:image_data => fixture_file_upload("/image.jpg", "image/jpeg"))
+    @pic[:height] = 60_000
+    assert_equal 60_000, @pic.height
+  end
+
+  def test_should_use_value_from_db_in_width_reader
+    @pic = ComplexPic.create!(:image_data => fixture_file_upload("/image.jpg", "image/jpeg"))
+    @pic[:width] = 60_000
+    assert_equal 60_000, @pic.width
+  end
+  
+end

data/test_rails/pic_test.rb

@@ -1,16 +1,24 @@
 require 'test_helper'
 
+class Pic < ActiveRecord::Base
+  has_image
+end
+
+class PicWithDifferentTableName < ActiveRecord::Base
+  set_table_name 'pics'
+end
+
 class PicTest < Test::Unit::TestCase
-  
   def setup
+    # Note: Be sure to not set the whole options hash in your tests below
     Pic.has_image_options = HasImage.default_options_for(Pic)
-    Pic.has_image_options[:base_path] = File.join(RAILS_ROOT, '/tmp')
+    Pic.has_image_options[:base_path] = File.join(RAILS_ROOT, 'tmp')
   end
-  
+
   def teardown
     FileUtils.rm_rf(File.join(RAILS_ROOT, 'tmp', 'pics'))
   end
-  
+
   def test_should_be_valid
     @pic = Pic.new(:image_data => fixture_file_upload("/image.jpg", "image/jpeg"))
     assert @pic.valid? , "#{@pic.errors.full_messages.to_sentence}"
@@ -47,14 +55,37 @@ class PicTest < Test::Unit::TestCase
     assert @pic.save!
   end
 
-  def test_regenerate_thumbnails
-    Pic.has_image_options = HasImage.default_options_for(Pic).merge(
-      :thumbnails => {:small => "100x100", :tiny => "16x16"})
+  def test_finding_from_url_path
     @pic = Pic.new(:image_data => fixture_file_upload("/image.jpg", "image/jpeg"))
     @pic.save!
-    assert @pic.regenerate_thumbnails
+    path = HasImage::Storage.partitioned_path @pic.id
+    assert_equal @pic, Pic.from_partitioned_path(path)
   end
 
+  def test_default_options_respect_table_name
+    assert_equal 'pics', HasImage.default_options_for(PicWithDifferentTableName)[:path_prefix]
+  end
+
+  def test_generate_thumbnails_on_create
+    Pic.has_image_options[:thumbnails] = {:tiny => "16x16"}
+    @pic = Pic.create!(:image_data => fixture_file_upload("/image.jpg", "image/jpeg"))
+    assert File.exist?(@pic.absolute_path(:tiny))
+  end
+
+  def test_doesnt_generate_thumbnails_if_option_disabled
+    Pic.has_image_options[:thumbnails] = {:tiny => "16x16"}
+    Pic.has_image_options[:auto_generate_thumbnails] = false
+    @pic = Pic.create!(:image_data => fixture_file_upload("/image.jpg", "image/jpeg"))
+    assert !File.exist?(@pic.absolute_path(:tiny))
+  end
+
+  def test_regenerate_thumbnails_succeeds
+    Pic.has_image_options[:thumbnails] = {:small => "100x100", :tiny => "16x16"}
+    
+    @pic = Pic.new(:image_data => fixture_file_upload("/image.jpg", "image/jpeg"))
+    @pic.save!
+    assert @pic.regenerate_thumbnails
+  end
 
   def test_create_model_without_setting_image_data
     assert Pic.new.save!
@@ -66,6 +97,13 @@ class PicTest < Test::Unit::TestCase
     assert @pic.destroy
   end
 
+  def test_destroy_should_not_remove_image_file_if_option_is_set
+    Pic.has_image_options[:delete] = false
+    @pic = Pic.create!(:image_data => fixture_file_upload("/image.jpg", "image/jpeg"))
+    @pic.destroy
+    assert File.exist?(@pic.absolute_path)
+  end
+
   def test_destroy_model_with_images_already_deleted_from_filesystem
     @pic = Pic.new
     @pic.save!
@@ -86,5 +124,30 @@ class PicTest < Test::Unit::TestCase
     assert @pic.valid?
   end
 
-end
+  def test_dimension_getters
+    Pic.has_image_options[:resize_to] = "100x200"
+    pic = Pic.create!(:image_data => fixture_file_upload("/image.jpg", "image/jpeg"))
+    assert_equal 100, pic.width
+    assert_equal 200, pic.height
+    assert_equal '100x200', pic.image_size
+  end
+
+  def test_image_isnt_resized_when_resize_to_set_to_nil
+    Pic.has_image_options[:resize_to] = nil
+    pic = Pic.create!(:image_data => fixture_file_upload("/image.jpg", "image/jpeg"))
+
+    assert_equal 1916, pic.width
+    assert_equal 1990, pic.height
+  end
+
+  def test_image_isnt_resized_but_converted_when_resize_to_set_to_nil
+    Pic.has_image_options[:resize_to] = nil
+    Pic.has_image_options[:convert_to] = 'PNG'
+    pic = Pic.create!(:image_data => fixture_file_upload("/image.jpg", "image/jpeg"))
+
+    assert_equal 'PNG', MiniMagick::Image.from_file(pic.absolute_path)[:format]
+    assert_equal 1916, pic.width
+    assert_equal 1990, pic.height
+  end
 
+end