attachment_saver 1.0.0

data/lib/processors/image_science.rb

@@ -0,0 +1,94 @@
+require 'image_science'
+require 'misc/image_science_extensions'
+require 'misc/extended_tempfile'
+require 'processors/image'
+
+class ImageScienceProcessorError < ImageProcessorError; end
+
+module AttachmentSaver
+  module Processors
+    module ImageScience
+      include Image
+      
+      def with_image(filename, &block)
+        ::ImageScience.with_image(filename) {|image| block.call(image.extend(Operations))}
+      end
+      
+      def with_image_attributes(filename, &block)
+        return with_image(filename, &block) unless ::ImageScience.respond_to?(:with_image_attributes)
+        ::ImageScience.with_image_attributes(filename) {|image| block.call(image)}
+      end
+      
+      def examine_attachment
+        with_image_attributes(uploaded_file_path) do |original_image|
+          self.width = original_image.width if respond_to?(:width)
+          self.height = original_image.height if respond_to?(:height)
+          self.content_type = original_image.mime_type unless self.class.attachment_options[:keep_content_type] || original_image.mime_type.nil?
+          self.file_extension = original_image.file_type_extension unless self.class.attachment_options[:keep_file_extension] || original_image.file_type_extension.nil?
+        end
+      rescue AttachmentSaverError
+        raise
+      rescue Exception => ex
+        raise ImageScienceProcessorError, "#{ex.class}: #{ex.message}", ex.backtrace
+      end
+      
+      def process_image(original_image, derived_format_name, resize_format)
+        resize_format = Image.from_geometry_string(resize_format) if resize_format.is_a?(String)
+
+        original_image.send(*resize_format) do |derived_image|
+          return nil unless want_format?(derived_format_name, derived_image.width, derived_image.height)
+
+          if derived_image.file_type == 'GIF' # && derived_image.depth != 8 # TODO: submit patch to add depth attribute
+            # as a special case hack, don't try and save 24-bit derived images into 8-bit-only GIF format
+            # (ImageScience doesn't resample back down, so it throws errors if we try to do that)
+            derived_content_type = 'image/png'
+            derived_extension = 'png'
+          else
+            # both original_filename and content_type must be defined for parents when using image processing
+            # - but apps can just define them using attr_accessor if they don't want them persisted to db
+            derived_content_type = derived_image.mime_type || original_image.mime_type || content_type # note that mime_type will return nil instead of returning any of the freeimage-invented content types
+            derived_extension = (derived_image.file_type || file_extension).downcase # in fact, derived_image.file_type should always work; the only situation in which it could return nil is if freeimage is extended to support a new image format but image_science_extensions isn't updated
+          end
+      
+          # we leverage tempfiles as discussed in the uploaded_file method
+          temp = ExtendedTempfile.new("asitemp", tempfile_directory, derived_extension)
+          temp.binmode
+          temp.close
+          derived_image.save(temp.path)
+          temp.open # we close & reopen so we see the file the processor wrote to, even if it created a new file rather than writing into our tempfile
+        
+          { :format_name => derived_format_name.to_s,
+            :width => derived_image.width,
+            :height => derived_image.height,
+            :content_type => derived_content_type,
+            :file_extension => derived_extension,
+            :uploaded_data => temp }
+        end
+      end
+      
+      module Operations
+        include AttachmentSaver::Processors::Image::Operations
+        
+        def file_type_extension
+          file_type.downcase
+        end
+        
+        def resize_to(new_width, new_height, &block)
+          resize(new_width, new_height) do |image|
+            image.extend Operations
+            block.call(image) # ImageScience itself doesn't accept a block argument (it yields only)
+          end
+        end
+        
+        def crop_to(new_width, new_height, &block) # crops to the center
+          left = (width - new_width)/2
+          right = (height - new_height)/2
+          with_crop(left, right, left + new_width, right + new_height) do |image|
+            image.extend Operations
+            block.call(image) # as for resize, with_crop doesn't take a block itself
+          end
+        end
+      end
+    end
+  end
+end

data/lib/processors/mini_magick.rb

@@ -0,0 +1,103 @@
+require 'mini_magick'
+require 'misc/mini_magick_extensions'
+require 'misc/extended_tempfile'
+require 'processors/image'
+
+class MiniMagickProcessorError < ImageProcessorError; end
+
+module AttachmentSaver
+  module Processors
+    module MiniMagick
+      include Image
+      
+      def with_image(filename, &block)
+        # note that we are instantiating minimagick on the file itself, not a copy (which is
+        # what gets produced if you call from_file); we don't do any mutating operations on
+        # our instances themselves (resize_to and crop_to create new instances).
+        if ::MiniMagick::Image.respond_to?(:open) # v3
+          image = ::MiniMagick::Image.open(filename)
+        else # v1
+          image = ::MiniMagick::Image.new(filename)
+        end
+        block.call(image.extend(Operations))
+      end
+      
+      def with_image_attributes(filename, &block)
+        # MiniMagick doesn't actually load the image, it just keeps a reference to the filename
+        # and invokes the imagemagick programs to determine attributes
+        with_image(filename, &block)
+      end
+      
+      def examine_attachment
+        with_image_attributes(uploaded_file_path) do |original_image|
+          self.content_type = original_image.mime_type unless self.class.attachment_options[:keep_content_type] || original_image.mime_type.blank?
+          self.file_extension = original_image.file_type_extension unless self.class.attachment_options[:keep_file_extension] || original_image.file_type_extension.blank?
+          self.width = original_image.width if respond_to?(:width)
+          self.height = original_image.height if respond_to?(:height)
+        end
+      rescue AttachmentSaverError
+        raise
+      rescue Exception => ex
+        raise MiniMagickProcessorError, "#{ex.class}: #{ex.message}", ex.backtrace
+      end
+      
+      def process_image(original_image, derived_format_name, resize_format)
+        resize_format = Image.from_geometry_string(resize_format) if resize_format.is_a?(String)
+
+        original_image.send(*resize_format) do |derived_image|
+          return nil unless want_format?(derived_format_name, derived_image.width, derived_image.height)
+
+          # both original_filename and content_type must be defined for parents when using image processing
+          # - but apps can just define them using attr_accessor if they don't want them persisted to db
+          derived_content_type = derived_image.mime_type || original_image.mime_type || content_type
+          derived_extension = derived_image.file_type_extension
+      
+          # we leverage tempfiles as discussed in the uploaded_file method
+          temp = ExtendedTempfile.new("asmtemp", tempfile_directory, derived_extension)
+          temp.binmode
+          temp.close
+          derived_image.write(temp.path)
+          temp.open # we close & reopen so we see the file the processor wrote to, even if it created a new file rather than writing into our tempfile
+        
+          { :format_name => derived_format_name.to_s,
+            :width => derived_image.width,
+            :height => derived_image.height,
+            :content_type => derived_content_type,
+            :file_extension => derived_extension,
+            :uploaded_data => temp }
+        end
+      end
+      
+      module Operations
+        include AttachmentSaver::Processors::Image::Operations
+        
+        def file_type_extension
+          case format.downcase
+            when 'jpeg' then 'jpg'
+            else format.downcase
+          end
+        end
+        
+        def format; @__format ||= self[:format]; end  # cached as each call to [] results in a process execution!
+        def width;   @__width ||= self[:width];  end  # note that we can cache as we don't ever modify instances -
+        def height; @__height ||= self[:height]; end  # whereas MiniMagick may, in general.
+        
+        def resize_to(new_width, new_height, &block)
+          image = dup
+          image.resize("#{new_width}x#{new_height}!")
+          image.extend Operations
+          block.call(image)
+        end
+        
+        def crop_to(new_width, new_height, &block) # crops to the center
+          left = (width - new_width)/2
+          right = (height - new_height)/2
+          image = dup
+          image << "-crop #{new_width}x#{new_height}+#{left}+#{right} +repage" # mini_magick's #crop doesn't support the repage flag
+          image.extend Operations
+          block.call(image)
+        end
+      end
+    end
+  end
+end

data/lib/processors/r_magick.rb

@@ -0,0 +1,120 @@
+begin
+  require 'RMagick'
+rescue LoadError
+  require 'rmagick'
+end
+require 'misc/extended_tempfile'
+require 'processors/image'
+
+class RMagickProcessorError < ImageProcessorError; end
+
+module AttachmentSaver
+  module Processors
+    module RMagick
+      include Image
+      
+      def with_image(filename, &block)
+        image = Magick::Image.read(filename).first
+        block.call(image.extend(Operations))
+      end
+      
+      def with_image_attributes(filename, &block)
+        image = Magick::Image.ping(filename).first
+        block.call(image.extend(Operations))
+      end
+      
+      def examine_attachment
+        with_image_attributes(uploaded_file_path) do |original_image|
+          self.width = original_image.width if respond_to?(:width)
+          self.height = original_image.height if respond_to?(:height)
+          self.content_type = original_image.corrected_mime_type unless self.class.attachment_options[:keep_content_type] || original_image.corrected_mime_type.nil?
+          self.file_extension = original_image.file_type_extension unless self.class.attachment_options[:keep_file_extension] || original_image.file_type_extension.nil?
+        end
+      rescue AttachmentSaverError
+        raise
+      rescue Exception => ex
+        raise RMagickProcessorError, "#{ex.class}: #{ex.message}", ex.backtrace
+      end
+      
+      def process_image(original_image, derived_format_name, resize_format)
+        resize_format = Image.from_geometry_string(resize_format) if resize_format.is_a?(String)
+
+        result = original_image.send(*resize_format) do |derived_image|
+          return nil unless want_format?(derived_format_name, derived_image.width, derived_image.height)
+
+          # both original_filename and content_type must be defined for parents when using image processing
+          # - but apps can just define them using attr_accessor if they don't want them persisted to db
+          derived_content_type = derived_image.corrected_mime_type || original_image.corrected_mime_type || content_type
+          derived_extension = derived_image.file_type_extension
+      
+          # we leverage tempfiles as discussed in the uploaded_file method
+          temp = ExtendedTempfile.new("asrtemp", tempfile_directory, derived_extension)
+          temp.binmode
+          temp.close
+          derived_image.write(temp.path)
+          temp.open # we close & reopen so we see the file the processor wrote to, even if it created a new file rather than writing into our tempfile
+        
+          { :format_name => derived_format_name.to_s,
+            :width => derived_image.width,
+            :height => derived_image.height,
+            :content_type => derived_content_type,
+            :file_extension => derived_extension,
+            :uploaded_data => temp }
+        end
+
+        # modern versions of RMagick don't leak memory.  however, the (many and large) internal
+        # buffers malloced inside the ImageMagick library are not allocated via the Ruby memory
+        # management functions.  as Ruby GC runs are normally triggered at the point when those Ruby
+        # memory management functions request a larger heap, ImageMagick's extra allocations will
+        # not trigger a GC run.  so while no memory has been leaked - all the allocations by the
+        # ImageMagick library *will* get freed when GC runs - GC will typically not run even if you
+        # process a series of images and end up using all of the memory that can be made available
+        # to the process, at which point your process dies!  until such time as RMagick rewraps the
+        # ImageMagick memory allocation functions to put them through Ruby's (as was done in the
+        # as-yet-uncompleted MagickWand project), we force a GC after each image processing to
+        # ensure that your processes stay happy.
+        GC.start
+        result
+      end
+      
+      module Operations
+        include AttachmentSaver::Processors::Image::Operations
+        
+        def corrected_mime_type
+          case mime_type
+            when 'image/x-jpeg'   then 'image/jpeg'
+            when 'image/x-magick' then nil
+            else mime_type
+          end
+        end
+        
+        def file_type_extension
+          case format.downcase
+            when 'jpeg' then 'jpg'
+            else format.downcase
+          end
+        end
+        
+        def width
+          columns
+        end
+        
+        def height
+          rows
+        end
+        
+        def resize_to(new_width, new_height, &block)
+          image = resize(new_width, new_height)
+          image.extend Operations
+          block.call(image)
+        end
+        
+        def crop_to(new_width, new_height, &block) # crops to the center
+          image = crop(Magick::CenterGravity, new_width, new_height, true)
+          image.extend Operations
+          block.call(image)
+        end
+      end
+    end
+  end
+end

data/test/attachment_saver_test.rb

@@ -0,0 +1,162 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+require 'attachment_saver'
+
+class AttachmentSaverTest < Test::Unit::TestCase
+  def test_split_filename
+    assert_equal ['a', nil],        AttachmentSaver::split_filename('a')
+    assert_equal ['a', ''],         AttachmentSaver::split_filename('a.')
+    assert_equal ['a', 'b'],        AttachmentSaver::split_filename('a.b')
+    assert_equal ['a', 'bcde'],     AttachmentSaver::split_filename('a.bcde')
+    assert_equal ['a.bcde', 'fgh'], AttachmentSaver::split_filename('a.bcde.fgh')
+  end
+  
+  class SomeModel
+    include AttachmentSaver::InstanceMethods
+    class_attribute :attachment_options
+
+    attr_accessor :size, :content_type, :original_filename
+  end
+  
+  module TempfileAttributes
+    def original_filename
+      "test.txt"
+    end
+    
+    def content_type
+      "text/plain"
+    end
+  end
+  
+  module ExtensionlessAttributes
+    def original_filename
+      "test"
+    end
+    
+    def content_type
+      "text/plain"
+    end
+  end
+  
+  module OriginalFilenameHasPathAttributes
+    def original_filename
+      " c:\\test/foo.txt "
+    end
+    
+    def content_type
+      "text/plain"
+    end
+  end
+  
+  def contents_of(file)
+    file.rewind
+    file.read
+  end
+  
+  def test_default_methods
+    model = SomeModel.new
+    assert_equal nil, model.uploaded_data
+    assert_equal nil, model.uploaded_file
+    assert_equal false, model.process_attachment?
+    assert File.directory?(model.tempfile_directory)
+  end
+  
+  def test_uploaded_data_setters_and_extensions
+    SomeModel.attachment_options = {}
+    
+    model = SomeModel.new
+    model.uploaded_data = 'test #1'
+    assert_equal 7, model.size
+    assert_equal nil, model.content_type
+    assert_equal nil, model.original_filename
+    assert_equal 'test #1', model.uploaded_data # before converting to an uploaded_file
+    assert_not_equal nil, model.uploaded_file
+    assert model.uploaded_file.is_a?(Tempfile)
+    assert_equal model.uploaded_file.object_id, model.uploaded_file.object_id, 'uploaded_file should return the same instance each time'
+    assert_equal 'test #1', model.uploaded_data # after converting to an uploaded_file
+    assert_equal 'test #1', contents_of(model.uploaded_file)
+    assert_equal 'test #1', model.uploaded_data
+    assert_equal 'bin', model.file_extension
+    model.file_extension = 'ext'
+    assert_equal 'ext', model.file_extension
+    
+    model = SomeModel.new
+    model.uploaded_data = StringIO.new('test #2')
+    assert_equal 7, model.size
+    assert_equal nil, model.content_type
+    assert_equal nil, model.original_filename
+    assert_not_equal nil, model.uploaded_file
+    assert model.uploaded_file.is_a?(Tempfile)
+    assert_equal model.uploaded_file.object_id, model.uploaded_file.object_id, 'uploaded_file should return the same instance each time'
+    assert_equal 'test #2', model.uploaded_data
+    assert_equal 'test #2', contents_of(model.uploaded_file)
+    assert_equal 'test #2', model.uploaded_data
+    assert_equal 'bin', model.file_extension
+    model.file_extension = 'ext'
+    assert_equal 'ext', model.file_extension
+    
+    Tempfile.open('test') do |tempfile|
+      tempfile.write('test #3')
+      model = SomeModel.new
+      model.uploaded_data = tempfile
+      assert_equal 7, model.size
+      assert_equal nil, model.content_type
+      assert_equal nil, model.original_filename
+      assert_equal tempfile.object_id, model.uploaded_file.object_id, 'uploaded_file should return the originally given tempfile'
+      assert_equal 'test #3', model.uploaded_data
+      assert_equal 'test #3', contents_of(model.uploaded_file)
+      assert_equal 'test #3', model.uploaded_data
+      assert_equal 'bin', model.file_extension
+      model.file_extension = 'ext'
+      assert_equal 'ext', model.file_extension
+    end
+    
+    Tempfile.open('test') do |tempfile|
+      tempfile.extend TempfileAttributes
+      tempfile.write('test #4')
+      model = SomeModel.new
+      model.uploaded_data = tempfile
+      assert_equal 7, model.size
+      assert_equal "text/plain", model.content_type
+      assert_equal "test.txt", model.original_filename
+      assert_equal tempfile.object_id, model.uploaded_file.object_id, 'uploaded_file should return the originally given tempfile'
+      assert_equal 'test #4', model.uploaded_data
+      assert_equal 'test #4', contents_of(model.uploaded_file)
+      assert_equal 'test #4', model.uploaded_data
+      assert_equal 'txt', model.file_extension
+      model.file_extension = 'ext'
+      assert_equal 'ext', model.file_extension
+    end
+    
+    Tempfile.open('test') do |tempfile|
+      tempfile.extend ExtensionlessAttributes
+      model = SomeModel.new
+      model.uploaded_data = tempfile
+      assert_equal "test", model.original_filename
+      assert_equal 'bin', model.file_extension
+      model.file_extension = 'ext'
+      assert_equal 'ext', model.file_extension
+    end
+    
+    Tempfile.open('test') do |tempfile|
+      tempfile.extend OriginalFilenameHasPathAttributes
+      
+      model = SomeModel.new
+      model.uploaded_data = tempfile
+      assert_equal "foo.txt", model.original_filename
+      assert_equal 'txt', model.file_extension
+      
+      SomeModel.attachment_options = {:keep_original_filename_path => true}
+      model = SomeModel.new
+      model.uploaded_data = tempfile
+      assert_equal "c:\\test/foo.txt", model.original_filename
+      assert_equal 'txt', model.file_extension
+    end
+    
+    model = SomeModel.new
+    model.uploaded_data = '' # this is what controllers get sent when there's a file field but no file selected; attachment_saver accordingly handles blank strings as a special case
+    assert_equal nil, model.uploaded_file
+    assert_equal nil, model.size
+    assert_equal nil, model.content_type
+    assert_equal nil, model.original_filename
+  end
+end