tdd-attachment_fu 0.9.6 → 0.9.9.b

data/CHANGELOG

@@ -1,3 +1,11 @@
+* Mar 15, 2010 *
+* Added a symbol syntax for parent-type-based size spec: calls the corresponding method on the current asset instance to
+  get a Hash of required thumbnails.  Lets us dynamically specify what would otherwise be hard-coded, which is useful
+  when the set of thumbnails for a given parent type varies depending on the usage context.
+
+* Aug 6, 2009 *
+* JPEG quality control finalized across processors (although CoreImage applies it in a rather fuzzy-logic way), with tests.
+
 * Aug 4, 2009 *
 * Supports the :aspect/'!' geometry flag in all processors
   (thanks to http://www.deepcalm.com/writing/cropped-thumbnails-in-attachment_fu-using-imagescience)

data/README

@@ -22,43 +22,80 @@ attachment_fu models
 ====================
 
 For all three of these storage options a table of metadata is required.  This table will contain information about the file (hence the 'meta') and its location.  This table has no restrictions on naming, unlike the extra table required for database storage, which must have a table name of db_files (and by convention a model of DbFile).
-  
+
 In the model there are two methods made available by this plugins: has_attachment and validates_as_attachment.
 
 has_attachment(options = {})
   This method accepts the options in a hash:
-    :content_type     # Allowed content types.
-                      # Allows all by default.  Use :image to allow all standard image types.
-    :min_size         # Minimum size allowed.
-                      # 1 byte is the default.
-    :max_size         # Maximum size allowed.
-                      # 1.megabyte is the default.
-    :size             # Range of sizes allowed.
-                      # (1..1.megabyte) is the default.  This overrides the :min_size and :max_size options.
-    :resize_to        # Used by RMagick to resize images.
-                      # Pass either an array of width/height, or a geometry string.
-    :thumbnails       # Specifies a set of thumbnails to generate.
-                      # This accepts a hash of filename suffixes and RMagick resizing options.
-                      # This option need only be included if you want thumbnailing.
-    :thumbnail_class  # Set which model class to use for thumbnails.
-                      # This current attachment class is used by default.
-    :jpeg_quality     # Used to provide explicit JPEG quality for thumbnail/resize saves.  Has to be an integer between 0 and 100.
-                      # Defaults vary depending on the processor (ImageScience: 100%, Rmagick/MiniMagick/Gd2: 75%, CoreImage: ~72%).
-                      # Note that only tdd-image_science (available from GitHub) currently supports explicit JPEG quality;
-                      # the default image_science currently forces 100%.
-    :path_prefix      # Path to store the uploaded files in.
-                      # Uses public/#{table_name} by default for the filesystem, and just #{table_name} for the S3 and Cloud Files backend.  
-                      # Setting this sets the :storage to :file_system.
-    :partition        # Whether to partiton files in directories like /0000/0001/image.jpg. Default is true. Only applicable to the :file_system backend.
-    :storage          # Specifies the storage system to use..
-                      # Defaults to :db_file.  Options are :file_system, :db_file, :s3, and :cloud_files.
-    :cloudfront       # If using S3 for storage, this option allows for serving the files via Amazon CloudFront.
-                      # Defaults to false.
-    :processor        # Sets the image processor to use for resizing of the attached image.
-                      # Options include ImageScience, Rmagick, MiniMagick, Gd2 and CoreImage.  Default is whatever is installed.
-    :uuid_primary_key # If your model's primary key is a 128-bit UUID in hexadecimal format, then set this to true.
-    :association_options  # attachment_fu automatically defines associations with thumbnails with has_many and belongs_to. If there are any additional options that you want to pass to these methods, then specify them here.
-    
+    :content_type         # Allowed content types.
+                          # Allows all by default.  Use :image to allow all standard image types.
+                          #
+    :min_size             # Minimum size allowed.
+                          # 1 byte is the default.
+                          #
+    :max_size             # Maximum size allowed.
+                          # 1.megabyte is the default.
+                          #
+    :size                 # Range of sizes allowed.
+                          # (1..1.megabyte) is the default.  This overrides the :min_size and :max_size options.
+                          #
+    :resize_to            # Used by RMagick to resize images.
+                          # Pass either an array of width/height, or a geometry string.
+                          #
+    :thumbnails           # Specifies a set of thumbnails to generate.
+                          # This accepts a hash of filename suffixes and RMagick resizing options.
+                          # This option need only be included if you want thumbnailing.
+                          # If you have a polymorphic parent relationship, you can provide parent-type-specific
+                          # thumbnail settings by using a pair with the type string as key and a Hash of thumbnail
+                          # definitions, or a method symbol, as value. The method symbol will call the named
+                          # method in order to get a dynamically-built Hash of thumbnail definitions, which gives
+                          # you full flexibility.
+                          # AttachmentFu automatically detects your first polymorphic +belongs_to+ relationship.
+                          #
+    :thumbnail_class      # Set which model class to use for thumbnails.
+                          # This current attachment class is used by default.
+                          #
+    :jpeg_quality         # Used to provide explicit JPEG quality for thumbnail/resize saves.  Can have multiple
+                          # formats:
+                          # * Integer from 0 (basically crap) to 100 (basically lossless, fat files).
+                          # * When relying on tdd-image_science, you can also use one of its +JPEG_xxx+ constants
+                          #   for predefined ratios/settings.
+                          # * You can also use a Hash, with keys being either  thumbnail symbols (I repeat:
+                          #   _symbols_) or surface boundaries.  A surface boundary is a string starting with either
+                          #   '<' or '>=', followed by a number of pixels.  This lets you specify per-thumbnail or
+                          #   per-general-thumbnail-"size" JPEG qualities. (which can be useful when you have a
+                          #   _lot_ of thumbnail options).  Surface example: +{ '<2000' => 90, '>=2000' => 75 }+.
+                          #
+                          # Defaults vary depending on the processor (ImageScience: 100%,
+                          # Rmagick/MiniMagick/Gd2: 75%, CoreImage: auto-adjust).
+                          # Note that only tdd-image_science (available from GitHub) currently supports explicit
+                          # JPEG quality; the default image_science currently forces 100%.
+                          #
+    :path_prefix          # Path to store the uploaded files in.
+                          # Uses public/#{table_name} by default for the filesystem, and just #{table_name} for the
+                          # S3 and Cloud Files backend.
+                          # Setting this sets the :storage to :file_system.
+                          #
+    :partition            # Whether to partiton files in directories like /0000/0001/image.jpg. Default is true.
+                          # Only applicable to the :file_system backend.
+                          #
+    :storage              # Specifies the storage system to use..
+                          # Defaults to :db_file.  Options are :file_system, :db_file, :s3, and :cloud_files.
+                          #
+    :cloudfront           # If using S3 for storage, this option allows for serving the files via Amazon CloudFront.
+                          # Defaults to false.
+                          #
+    :processor            # Sets the image processor to use for resizing of the attached image.
+                          # Options include ImageScience, Rmagick, MiniMagick, Gd2 and CoreImage.  Default is
+                          # whatever is installed.
+                          #
+    :uuid_primary_key     # If your model's primary key is a 128-bit UUID in hexadecimal format, then set this to
+                          # true.
+                          #
+    :association_options  # attachment_fu automatically defines associations with thumbnails with has_many and
+                          # belongs_to. If there are any additional options that you want to pass to these methods,
+                          # then specify them here.
+
 
   Examples:
     has_attachment :max_size => 1.kilobyte
@@ -69,7 +106,7 @@ has_attachment(options = {})
     has_attachment :content_type => ['application/pdf', :image], :resize_to => 'x50'
     has_attachment :thumbnails => { :thumb => [50, 50], :geometry => 'x50' }
     has_attachment :storage => :file_system, :path_prefix => 'public/files'
-    has_attachment :storage => :file_system, :path_prefix => 'public/files', 
+    has_attachment :storage => :file_system, :path_prefix => 'public/files',
                    :content_type => :image, :resize_to => [50,50], :partition => false
     has_attachment :storage => :file_system, :path_prefix => 'public/files',
                    :thumbnails => { :thumb => [50, 50], :geometry => 'x50' }
@@ -77,9 +114,28 @@ has_attachment(options = {})
     has_attachment :store => :s3, :cloudfront => true
     has_attachment :storage => :cloud_files
 
+    # Let's say we have a polymorphic belongs_to, e.g. called 'imageable', where imageable_type (or whatever the
+    # :foreign_type option was set to) can be, among other things, 'Product', 'User' or 'Editorial', each of which
+    # should have extra thumbnails:
+
+    has_attachment :thumbnails => { :thumb => [50, 50], :geometry => 'x50',
+      :products   => { :large_thumb => '169x169!', :zoomed => '500x500>' },
+      :editorials => { :fullsize => '150x100>' },
+      :users      => { :avatar => '64x64!' } }
+
+    # JPEG qualities…
+
+    has_attachment :jpeg_quality => 75
+    has_attachment :jpeg_quality => 80 | ImageScience::JPEG_PROGRESSIVE
+    has_attachment :thumbnails => { :thumb => [50, 50], :geometry => 'x50' },
+      :jpeg_quality => { nil => 75, :thumb => 90, :geometry => 90 }
+    has_attachment :thumbnails => { :thumb => [50, 50], :geometry => 'x50' },
+      :jpeg_quality => { '<2000' => 90, '>=2000' => 75 }
+}
+
 validates_as_attachment
   This method prevents files outside of the valid range (:min_size to :max_size, or the :size range) from being saved.  It does not however, halt the upload of such files.  They will be uploaded into memory regardless of size before validation.
-  
+
   Example:
     validates_as_attachment
 
@@ -98,12 +154,12 @@ Fields for attachment_fu metadata tables...
   that reference images that will be thumbnailed:
     parent_id,    :integer  # id of parent image (on the same table, a self-referencing foreign-key).
                             # Only populated if the current object is a thumbnail.
-    thumbnail,    :string   # the 'type' of thumbnail this attachment record describes.  
+    thumbnail,    :string   # the 'type' of thumbnail this attachment record describes.
                             # Only populated if the current object is a thumbnail.
                             # Usage:
                             # [ In Model 'Avatar' ]
-                            #   has_attachment :content_type => :image, 
-                            #                  :storage => :file_system, 
+                            #   has_attachment :content_type => :image,
+                            #                  :storage => :file_system,
                             #                  :max_size => 500.kilobytes,
                             #                  :resize_to => '320x200>',
                             #                  :thumbnails => { :small => '10x10>',
@@ -112,7 +168,7 @@ Fields for attachment_fu metadata tables...
                             # @user.avatar.thumbnails.first.thumbnail #=> 'small'
   that reference files stored in the database (:db_file):
     db_file_id,   :integer  # id of the file in the database (foreign key)
-    
+
 Field for attachment_fu db_files table:
   data, :binary # binary file data, for use in database file storage
 
@@ -126,7 +182,7 @@ There are two parts of the upload form that differ from typical usage.
   1. Include ':multipart => true' in the html options of the form_for tag.
     Example:
       <% form_for(:attachment_metadata, :url => { :action => "create" }, :html => { :multipart => true }) do |form| %>
-      
+
   2. Use the file_field helper with :uploaded_data as the field name.
     Example:
       <%= form.file_field :uploaded_data %>
@@ -154,7 +210,7 @@ Example:
   def readme
     send_file '/path/to/readme.txt', :type => 'plain/text', :disposition => 'inline'
   end
-  
+
 See the possible values for send_file for reference.
 
 
@@ -167,7 +223,7 @@ Example in controller:
     @attachable_file = AttachmentMetadataModel.new(params[:attachable])
     if @attachable_file.save
       flash[:notice] = 'Attachment was successfully created.'
-      redirect_to attachable_url(@attachable_file)     
+      redirect_to attachable_url(@attachable_file)
     else
       render :action => :new
     end
@@ -176,12 +232,12 @@ Example in controller:
 attachement_fu scripting
 ====================================
 
-You may wish to import a large number of images or attachments. 
-The following example shows how to upload a file from a script. 
+You may wish to import a large number of images or attachments.
+The following example shows how to upload a file from a script.
 
 #!/usr/bin/env ./script/runner
 
-# required to use ActionController::TestUploadedFile 
+# required to use ActionController::TestUploadedFile
 require 'action_controller'
 require 'action_controller/test_process.rb'
 

data/lib/technoweenie/attachment_fu.rb

@@ -46,7 +46,20 @@ module Technoweenie # :nodoc:
       # *  <tt>:max_size</tt> - Maximum size allowed.  1.megabyte is the default.
       # *  <tt>:size</tt> - Range of sizes allowed.  (1..1.megabyte) is the default.  This overrides the :min_size and :max_size options.
       # *  <tt>:resize_to</tt> - Used by RMagick to resize images.  Pass either an array of width/height, or a geometry string.
-      # *  <tt>:thumbnails</tt> - Specifies a set of thumbnails to generate.  This accepts a hash of filename suffixes and RMagick resizing options.
+      # *  <tt>:jpeg_quality</tt> - Used to provide explicit JPEG quality for thumbnail/resize saves.  Can have multiple formats:
+      #      * Integer from 0 (basically crap) to 100 (basically lossless, fat files).
+      #      * When relying on ImageScience, you can also use one of its +JPEG_xxx+ constants for predefined ratios/settings.
+      #      * You can also use a Hash, with keys being either  thumbnail symbols (I repeat: _symbols_) or surface boundaries.
+      #        A surface boundary is a string starting with either '<' or '>=', followed by a number of pixels.  This lets you
+      #        specify per-thumbnail or per-general-thumbnail-"size" JPEG qualities. (which can be useful when you have a
+      #        _lot_ of thumbnail options).  Surface example:  +{ '<2000' => 90, '>=2000' => 75 }+.
+      #      Defaults vary depending on the processor (ImageScience: 100%, Rmagick/MiniMagick/Gd2: 75%,
+      #      CoreImage: auto-adjust). Note that only tdd-image_science (available from GitHub) currently supports explicit JPEG quality;
+      #      the default image_science currently forces 100%.
+      # *  <tt>:thumbnails</tt> - Specifies a set of thumbnails to generate.  This accepts a hash of filename suffixes and
+      #      RMagick resizing options.  If you have a polymorphic parent relationship, you can provide parent-type-specific
+      #      thumbnail settings by using a pair with the type string as key and a Hash of thumbnail definitions as value.
+      #      AttachmentFu automatically detects your first polymorphic +belongs_to+ relationship.
       # *  <tt>:thumbnail_class</tt> - Set what class to use for thumbnails.  This attachment class is used by default.
       # *  <tt>:path_prefix</tt> - path to store the uploaded files.  Uses public/#{table_name} by default for the filesystem, and just #{table_name}
       #      for the S3 backend.  Setting this sets the :storage to :file_system.
@@ -251,6 +264,13 @@ module Technoweenie # :nodoc:
           tmp.close
         end
       end
+
+      def polymorphic_relation_type_column
+        return @@_polymorphic_relation_type_column if defined?(@@_polymorphic_relation_type_column)
+        # Checked against ActiveRecord 1.15.6 through Edge @ 2009-08-05.
+        ref = reflections.values.detect { |r| r.macro == :belongs_to && r.options[:polymorphic] }
+        @@_polymorphic_relation_type_column = ref && ref.options[:foreign_type]
+      end
     end
 
     module InstanceMethods
@@ -453,7 +473,22 @@ module Technoweenie # :nodoc:
           if @saved_attachment
             if respond_to?(:process_attachment_with_processing) && thumbnailable? && !attachment_options[:thumbnails].blank? && parent_id.nil?
               temp_file = temp_path || create_temp_file
-              attachment_options[:thumbnails].each { |suffix, size| create_or_update_thumbnail(temp_file, suffix, *size) }
+              attachment_options[:thumbnails].each { |suffix, size|
+                if size.is_a?(Symbol)
+                  parent_type = polymorphic_parent_type
+                  next unless parent_type && [parent_type, parent_type.tableize].include?(suffix.to_s) && respond_to?(size)
+                  size = send(size)
+                end
+                if size.is_a?(Hash)
+                  parent_type = polymorphic_parent_type
+                  next unless parent_type && [parent_type, parent_type.tableize].include?(suffix.to_s)
+                  size.each { |ppt_suffix, ppt_size|
+                    create_or_update_thumbnail(temp_file, ppt_suffix, *ppt_size)
+                  }
+                else
+                  create_or_update_thumbnail(temp_file, suffix, *size)
+                end
+              }
             end
             save_to_storage
             @temp_paths.clear
@@ -509,6 +544,27 @@ module Technoweenie # :nodoc:
         def destroy_thumbnails
           self.thumbnails.each { |thumbnail| thumbnail.destroy } if thumbnailable?
         end
+
+        def polymorphic_parent_type
+          rel_name = self.class.polymorphic_relation_type_column
+          rel_name && send(rel_name)
+        end
+
+        def get_jpeg_quality(require_0_to_100 = true)
+          quality = attachment_options[:jpeg_quality]
+          if quality.is_a?(Hash)
+            sbl_quality  = thumbnail && quality[thumbnail.to_sym]
+            sbl_quality  = nil if sbl_quality && require_0_to_100 && !sbl_quality.to_i.between?(0, 100)
+            surface      = (width || 1) * (height || 1)
+            size_quality = quality.detect { |k, v|
+              next unless k.is_a?(String) && k =~ /^(<|>=)(\d+)$/
+              op, threshold = $1, $2.to_i
+              surface.send(op, threshold)
+            }
+            quality = sbl_quality || size_quality && size_quality[1]
+          end
+          return quality && (!require_0_to_100 || quality.to_i.between?(0, 100)) ? quality : nil
+        end
     end
   end
 end

data/lib/technoweenie/attachment_fu/processors/core_image_processor.rb

@@ -44,16 +44,17 @@ module Technoweenie # :nodoc:
             processor.render do |result|
               self.width  = result.extent.size.width  if respond_to?(:width)
               self.height = result.extent.size.height if respond_to?(:height)
-              
-              # Get a new temp_path for the image before saving
               out_file = random_tempfile_filename
               temp_paths.unshift Tempfile.new(out_file, Technoweenie::AttachmentFu.tempfile_path).path
               properties = nil
-              jpeg = out_file =~ /\.jpe?g\z/i
-              quality = attachment_options[:jpeg_quality]
-              quality = quality ? quality.to_i : -1
-              properties = { OSX::NSImageCompressionFactor => quality / 100.0 } if jpeg && quality.between?(0, 100)
+              # We don't check the source image since we're forcing the output to JPEG, apparently…
+              # Beware: apparently CoreImage only takes the percentage as a HINT, using a different actual quality…
+              quality = get_jpeg_quality
+              properties = { OSX::NSImageCompressionFactor => quality / 100.0 } if quality
               result.save(self.temp_path, OSX::NSJPEGFileType, properties)
+              #             
+              # puts "#{self.temp_path} @ #{quality.inspect} -> #{%x(identify -format '%Q' "#{self.temp_path}")}"
+              # 
               self.size = File.size(self.temp_path)
             end
           end          

data/lib/technoweenie/attachment_fu/processors/gd2_processor.rb

@@ -44,16 +44,13 @@ module Technoweenie # :nodoc:
               w, h = [img.width, img.height] / size.to_s
               img.resize!(w, h, false)
             end
+            self.width  = img.width  if respond_to?(:width)
+            self.height = img.height if respond_to?(:height)
             out_file = random_tempfile_filename
             temp_paths.unshift out_file
             jpeg = out_file =~ /\.jpe?g\z/i
-            quality = attachment_options[:jpeg_quality]
-            quality = quality ? quality.to_i : -1
-            self.size = if jpeg && quality.between?(0, 100)
-              img.export(self.temp_path, :quality => quality)
-            else
-              img.export(self.temp_path)
-            end
+            quality = jpeg && get_jpeg_quality
+            self.size = img.export(self.temp_path, quality ? { :quality => quality } : {})
           end
 
       end

data/lib/technoweenie/attachment_fu/processors/image_science_processor.rb

@@ -40,7 +40,7 @@ module Technoweenie # :nodoc:
               self.height = img.height if respond_to?(:height)
 
               # We don't check for quality being a 0-100 value as we also allow FreeImage JPEG_xxx constants.
-              quality = attachment_options[:jpeg_quality]
+              quality = content_type[/jpe?g/i] && get_jpeg_quality(false)
               # Traditional ImageScience has a 1-arg save method, tdd-image_science has 1 mandatory + 1 optional
               if quality && img.method(:save).arity == -2
                 img.save self.temp_path, quality

data/lib/technoweenie/attachment_fu/processors/mini_magick_processor.rb

@@ -38,18 +38,13 @@ module Technoweenie # :nodoc:
         # Performs the actual resizing operation for a thumbnail
         def resize_image(img, size)
           size = size.first if size.is_a?(Array) && size.length == 1
+          format = img[:format]
           img.combine_options do |commands|
             commands.strip unless attachment_options[:keep_profile]
 
             # GIF is not handled correctly, so we move to PNG, as in other processors…
-            format = img['format']
             if format == 'GIF'
               commands.format('PNG')
-            elsif format == 'JPEG'
-              quality = attachment_options[:jpeg_quality]
-              quality = quality ? quality.to_i : -1
-              # FIXME: this DOESN'T work, for whatever reason…
-              commands.quality(quality) if quality.between?(0, 100)
             end
             
             if size.is_a?(Fixnum) || (size.is_a?(Array) && size.first.is_a?(Fixnum))
@@ -101,7 +96,16 @@ module Technoweenie # :nodoc:
               commands.resize(size.to_s)
             end
           end
+          dims = img[:dimensions]
+          self.width  = dims[0] if respond_to?(:width)
+          self.height = dims[1] if respond_to?(:height)
+          # Has to be done this far so we get proper dimensions
+          if format == 'JPEG'
+            quality = get_jpeg_quality
+            img.quality(quality) if quality
+          end
           temp_paths.unshift img
+          self.size = File.size(self.temp_path)
         end
 
         def calculate_offset(image_width,image_height,image_aspect,thumb_width,thumb_height,thumb_aspect)

data/lib/technoweenie/attachment_fu/processors/rmagick_processor.rb

@@ -49,15 +49,13 @@ module Technoweenie # :nodoc:
           else
             img.change_geometry(size.to_s) { |cols, rows, image| image.resize!(cols<1 ? 1 : cols, rows<1 ? 1 : rows) }
           end
+          self.width  = img.columns if respond_to?(:width)
+          self.height = img.rows    if respond_to?(:height)
           img.strip! unless attachment_options[:keep_profile]
-          opts = attachment_options
-          out_file = write_to_temp_file(img.to_blob {
-            qty = opts[:jpeg_quality]
-            qty = qty ? qty.to_i : -1
-            # FIXME: this DOESN'T work, for whatever reason…
-            self.quality = qty if img.format.to_s[/JPEG/] && qty.between?(0, 100)
-          })
+          quality = img.format.to_s[/JPEG/] && get_jpeg_quality
+          out_file = write_to_temp_file(img.to_blob { self.quality = quality if quality })
           temp_paths.unshift out_file
+          self.size = File.size(self.temp_path)
         end
       end
     end

data/test/basic_test.rb

@@ -4,15 +4,15 @@ class BasicTest < Test::Unit::TestCase
   def test_should_set_default_min_size
     assert_equal 1, Attachment.attachment_options[:min_size]
   end
-  
+
   def test_should_set_default_max_size
     assert_equal 1.megabyte, Attachment.attachment_options[:max_size]
   end
-  
+
   def test_should_set_default_size
     assert_equal (1..1.megabyte), Attachment.attachment_options[:size]
   end
-  
+
   def test_should_set_default_thumbnails_option
     assert_equal Hash.new, Attachment.attachment_options[:thumbnails]
   end
@@ -20,19 +20,19 @@ class BasicTest < Test::Unit::TestCase
   def test_should_set_default_thumbnail_class
     assert_equal Attachment, Attachment.attachment_options[:thumbnail_class]
   end
-  
+
   def test_should_normalize_content_types_to_array
     assert_equal %w(pdf), PdfAttachment.attachment_options[:content_type]
     assert_equal %w(pdf doc txt), DocAttachment.attachment_options[:content_type]
     assert_equal Technoweenie::AttachmentFu.content_types, ImageAttachment.attachment_options[:content_type]
     assert_equal ['pdf'] + Technoweenie::AttachmentFu.content_types, ImageOrPdfAttachment.attachment_options[:content_type]
   end
-  
+
   def test_should_sanitize_content_type
     @attachment = Attachment.new :content_type => ' foo '
     assert_equal 'foo', @attachment.content_type
   end
-  
+
   def test_should_sanitize_filenames
     @attachment = Attachment.new :filename => 'blah/foo.bar'
     assert_equal 'foo.bar',    @attachment.filename
@@ -42,29 +42,79 @@ class BasicTest < Test::Unit::TestCase
 
     @attachment.filename = 'f o!O-.bar'
     assert_equal 'f_o_O-.bar', @attachment.filename
-    
+
     @attachment.filename = 'sheeps_says_bææ'
     assert_equal 'sheeps_says_b__', @attachment.filename
 
     @attachment.filename = nil
     assert_nil @attachment.filename
   end
-  
+
   def test_should_convert_thumbnail_name
     @attachment = FileAttachment.new :filename => 'foo.bar'
     assert_equal 'foo.bar',           @attachment.thumbnail_name_for(nil)
     assert_equal 'foo.bar',           @attachment.thumbnail_name_for('')
     assert_equal 'foo_blah.bar',      @attachment.thumbnail_name_for(:blah)
     assert_equal 'foo_blah.blah.bar', @attachment.thumbnail_name_for('blah.blah')
-    
+
     @attachment.filename = 'foo.bar.baz'
     assert_equal 'foo.bar_blah.baz', @attachment.thumbnail_name_for(:blah)
   end
-  
+
   def test_should_require_valid_thumbnails_option
     klass = Class.new(ActiveRecord::Base)
     assert_raise ArgumentError do
       klass.has_attachment :thumbnails => []
     end
   end
+
+  class ::ImageWithPolymorphicThumbsAttachment
+    cattr_accessor :thumbnail_creations
+
+    def create_or_update_thumbnail(path, thumb, *size)
+      @@thumbnail_creations[thumb] = size.size == 1 ? size.first : size
+    end
+
+    def self.reset_creations
+      @@thumbnail_creations = {}
+    end
+  end
+
+  def test_should_handle_polymorphic_thumbnails_option
+    assert_polymorphic_thumb_creation nil,
+      :thumb => [50, 50], :geometry => 'x50'
+    assert_polymorphic_thumb_creation 'Product',
+      :thumb => [50, 50], :geometry => 'x50', :large_thumb => '169x169!', :zoomed => '500x500>'
+    assert_polymorphic_thumb_creation 'Editorial',
+      :thumb => [50, 50], :geometry => 'x50', :fullsize => '150x100>'
+    assert_polymorphic_thumb_creation 'User',
+      :thumb => [50, 50], :geometry => 'x50', :avatar => '64x64!'
+  end
+
+  def test_should_compute_per_thumbnail_jpeg_quality
+    assert_jpeg_quality :thumb, 90
+    assert_jpeg_quality :avatar, 85
+    assert_jpeg_quality :large, 75
+    assert_jpeg_quality :large, 0x200 | 75, false
+    assert_jpeg_quality nil, 75
+  end
+
+private
+  def assert_jpeg_quality(thumbnail, quality, require_0_to_100 = true)
+    klass = ImageWithPerThumbJpegAttachment
+    w, h = if thumbnail
+      klass.attachment_options[:thumbnails][thumbnail].scan(/\d+/)
+    else
+      klass.attachment_options[:resize_to].scan(/\d+/)
+    end
+    attachment = klass.new(:thumbnail => thumbnail, :width => w, :height => h)
+    assert_equal quality, attachment.send(:get_jpeg_quality, require_0_to_100)
+  end
+
+  def assert_polymorphic_thumb_creation(parent, defs)
+    attachment_model ImageWithPolymorphicThumbsAttachment
+    attachment_model.reset_creations
+    attachment = upload_file :filename => '/files/rails.png', :imageable_type => parent.to_s.classify, :imageable_id => nil
+    assert_equal defs, attachment_model.thumbnail_creations
+  end
 end

data/test/fixtures/attachment.rb

@@ -44,6 +44,23 @@ class ImageWithThumbsAttachment < Attachment
   # end
 end
 
+class ImageWithPerThumbJpegAttachment < Attachment
+  has_attachment :resize_to => '500x500!',
+    :thumbnails => { :thumb => '50x50!', :large => '300x300!', :avatar => '64x64!' },
+    :jpeg_quality => { :thumb => 90, '<5000' => 85, '>=5000' => 75, :large => 0x200 | 75 }
+end
+
+class ImageWithPolymorphicThumbsAttachment < Attachment
+  belongs_to :imageable, :polymorphic => true
+  has_attachment :thumbnails => {
+    :thumb      => [50, 50],
+    :geometry   => 'x50',
+    :products   => { :large_thumb => '169x169!', :zoomed => '500x500>' },
+    :editorials => { :fullsize => '150x100>' },
+    'User'      => { :avatar => '64x64!' }
+  }
+end
+
 class FileAttachment < ActiveRecord::Base
   has_attachment :path_prefix => 'vendor/plugins/attachment_fu/test/files', :processor => :rmagick
   validates_as_attachment
@@ -133,6 +150,14 @@ begin
       :processor => :image_science, :thumbnails => { :thumb => [50, 51], :geometry => '31>', :aspect => '25x25!' }, :resize_to => 55,
       :jpeg_quality => 75
   end
+
+  class ImageScienceWithPerThumbJpegAttachment < ImageScienceAttachment
+    has_attachment :path_prefix => 'vendor/plugins/attachment_fu/test/files',
+      :processor => :image_science,
+      :resize_to => '100x100',
+      :thumbnails => { :thumb => [50, 50], :editorial => '300x120', :avatar => '64x64!' },
+      :jpeg_quality => { :thumb => 90, '<5000' => 80, '>=5000' => 75 }
+  end
 rescue MissingSourceFile
   puts $!.message
   puts "no ImageScience"
@@ -145,11 +170,18 @@ begin
   end
 
   class LowerQualityCoreImageAttachment < CoreImageAttachment
-    set_table_name 'core_image_attachments'
     has_attachment :path_prefix => 'vendor/plugins/attachment_fu/test/files',
       :processor => :core_image, :thumbnails => { :thumb => [50, 51], :geometry => '31>', :aspect => '25x25!' }, :resize_to => 55,
       :jpeg_quality => 50
   end
+
+  class CoreImageWithPerThumbJpegAttachment < CoreImageAttachment
+    has_attachment :path_prefix => 'vendor/plugins/attachment_fu/test/files',
+      :processor => :core_image,
+      :resize_to => '100x100',
+      :thumbnails => { :thumb => [50, 50], :editorial => '300x120', :avatar => '64x64!' },
+      :jpeg_quality => { :thumb => 90, '<5000' => 80, '>=5000' => 75 }
+  end
 rescue MissingSourceFile
   puts $!.message
   puts "no CoreImage"
@@ -160,7 +192,7 @@ begin
     has_attachment :path_prefix => 'vendor/plugins/attachment_fu/test/files',
       :processor => :mini_magick, :thumbnails => { :thumb => [50, 51], :geometry => '31>', :aspect => '25x25!' }, :resize_to => 55
   end
-
+  
   class ImageThumbnailCrop < MiniMagickAttachment
     has_attachment :path_prefix => 'vendor/plugins/attachment_fu/test/files',
     :thumbnails => { :square => "50x50c", :vertical => "30x60c", :horizontal => "60x30c"}
@@ -194,13 +226,21 @@ begin
     end
   end
 
-  class LowerQualityMiniMagickAttachment < MiniMagickAttachment
+  class LowerQualityMiniMagickAttachment < ActiveRecord::Base
     set_table_name 'mini_magick_attachments'
     has_attachment :path_prefix => 'vendor/plugins/attachment_fu/test/files',
       :processor => :mini_magick, :thumbnails => { :thumb => [50, 51], :geometry => '31>', :aspect => '25x25!' }, :resize_to => 55,
       :jpeg_quality => 50
   end
 
+  class MiniMagickWithPerThumbJpegAttachment < MiniMagickAttachment
+    has_attachment :path_prefix => 'vendor/plugins/attachment_fu/test/files',
+      :processor => :mini_magick,
+      :resize_to => '100x100',
+      :thumbnails => { :thumb => [50, 50], :editorial => '300x120', :avatar => '64x64!' },
+      :jpeg_quality => { :thumb => 90, '<5000' => 80, '>=5000' => 75 }
+  end
+
 rescue MissingSourceFile
   puts $!.message
   puts "no Mini Magick"
@@ -217,6 +257,14 @@ begin
       :processor => :gd2, :thumbnails => { :thumb => [50, 51], :geometry => '31>', :aspect => '25x25!' }, :resize_to => 55,
       :jpeg_quality => 50
   end
+
+  class GD2WithPerThumbJpegAttachment < GD2Attachment
+    has_attachment :path_prefix => 'vendor/plugins/attachment_fu/test/files',
+      :processor => :gd2,
+      :resize_to => '100x100',
+      :thumbnails => { :thumb => [50, 50], :editorial => '300x120', :avatar => '64x64!' },
+      :jpeg_quality => { :thumb => 90, '<5000' => 80, '>=5000' => 75 }
+  end
 rescue MissingSourceFile
   puts $!.message
   puts "no GD2"

data/test/processors/core_image_test.rb

@@ -35,12 +35,20 @@ class CoreImageTest < Test::Unit::TestCase
 
     def test_should_handle_jpeg_quality
       attachment_model CoreImageAttachment
-      attachment = upload_file :filename => '/files/rails.jpg'
+      attachment = upload_file :filename => '/files/rails.jpg', :content_type => 'image/jpeg'
       full_size = attachment.size
       attachment_model LowerQualityCoreImageAttachment
-      attachment = upload_file :filename => '/files/rails.jpg'
+      attachment = upload_file :filename => '/files/rails.jpg', :content_type => 'image/jpeg'
       lq_size = attachment.size
       assert lq_size <= full_size * 0.9, 'Lower-quality JPEG filesize should be congruently smaller'
+
+      # FIXME: wait for Marcus' reply to determine whether I can get exact-quality output or need to adjust for CoreImage.
+      # attachment_model CoreImageWithPerThumbJpegAttachment
+      # attachment = upload_file :filename => '/files/rails.jpg', :content_type => 'image/jpeg'
+      # assert_file_jpeg_quality attachment, :thumb, 90
+      # assert_file_jpeg_quality attachment, :avatar, 80
+      # assert_file_jpeg_quality attachment, :editorial, 75
+      # assert_file_jpeg_quality attachment, nil, 75
     end
   else
     def test_flunk

data/test/processors/gd2_test.rb

@@ -29,12 +29,19 @@ class GD2Test < Test::Unit::TestCase
 
     def test_should_handle_jpeg_quality
       attachment_model GD2Attachment
-      attachment = upload_file :filename => '/files/rails.jpg'
+      attachment = upload_file :filename => '/files/rails.jpg', :content_type => 'image/jpeg'
       full_size = attachment.size
       attachment_model LowerQualityGD2Attachment
-      attachment = upload_file :filename => '/files/rails.jpg'
+      attachment = upload_file :filename => '/files/rails.jpg', :content_type => 'image/jpeg'
       lq_size = attachment.size
       assert lq_size <= full_size * 0.9, 'Lower-quality JPEG filesize should be congruently smaller'
+      
+      attachment_model GD2WithPerThumbJpegAttachment
+      attachment = upload_file :filename => '/files/rails.jpg', :content_type => 'image/jpeg'
+      assert_file_jpeg_quality attachment, :thumb, 90
+      assert_file_jpeg_quality attachment, :avatar, 80
+      assert_file_jpeg_quality attachment, :editorial, 75
+      assert_file_jpeg_quality attachment, nil, 75
     end
   else
     def test_flunk

data/test/processors/image_science_test.rb

@@ -28,16 +28,23 @@ class ImageScienceTest < Test::Unit::TestCase
     end
     
     def test_should_handle_jpeg_quality
-      attachment = upload_file :filename => '/files/rails.jpg'
+      attachment = upload_file :filename => '/files/rails.jpg', :content_type => 'image/jpeg'
       full_size = attachment.size
       attachment_model ImageScienceLowerQualityAttachment
-      attachment = upload_file :filename => '/files/rails.jpg'
+      attachment = upload_file :filename => '/files/rails.jpg', :content_type => 'image/jpeg'
       lq_size = attachment.size
       if ImageScience.instance_method(:save).arity == -2 # tdd-image_science: JPEG quality processing
         assert lq_size <= full_size * 0.75, 'Lower-quality JPEG filesize should be congruently smaller'
       else
         assert_equal full_size, lq_size, 'Unsupported lower-quality JPEG should yield exact same file size'
       end
+      
+      attachment_model ImageScienceWithPerThumbJpegAttachment
+      attachment = upload_file :filename => '/files/rails.jpg', :content_type => 'image/jpeg'
+      assert_file_jpeg_quality attachment, :thumb, 90
+      assert_file_jpeg_quality attachment, :avatar, 80
+      assert_file_jpeg_quality attachment, :editorial, 75
+      assert_file_jpeg_quality attachment, nil, 75
     end
   else
     def test_flunk

data/test/processors/mini_magick_test.rb

@@ -66,13 +66,19 @@ class MiniMagickTest < Test::Unit::TestCase
 
     def test_should_handle_jpeg_quality
       attachment_model MiniMagickAttachment
-      attachment = upload_file :filename => '/files/rails.jpg'
+      attachment = upload_file :filename => '/files/rails.jpg', :content_type => 'image/jpeg'
       full_size = attachment.size
       attachment_model LowerQualityMiniMagickAttachment
-      attachment = upload_file :filename => '/files/rails.jpg'
+      attachment = upload_file :filename => '/files/rails.jpg', :content_type => 'image/jpeg'
       lq_size = attachment.size
-      puts "FULL: #{full_size} - LQ: #{lq_size}"
       assert lq_size <= full_size * 0.9, 'Lower-quality JPEG filesize should be congruently smaller'
+      
+      attachment_model MiniMagickWithPerThumbJpegAttachment
+      attachment = upload_file :filename => '/files/rails.jpg', :content_type => 'image/jpeg'
+      assert_file_jpeg_quality attachment, :thumb, 90
+      assert_file_jpeg_quality attachment, :avatar, 80
+      assert_file_jpeg_quality attachment, :editorial, 75
+      assert_file_jpeg_quality attachment, nil, 75
     end
   else
     def test_flunk

data/test/processors/rmagick_test.rb

@@ -251,13 +251,19 @@ class RmagickTest < Test::Unit::TestCase
 
     def test_should_handle_jpeg_quality
       attachment_model ImageWithThumbsAttachment
-      attachment = upload_file :filename => '/files/rails.jpg'
+      attachment = upload_file :filename => '/files/rails.jpg', :content_type => 'image/jpeg'
       full_size = attachment.size
       attachment_model LowerQualityAttachment
-      attachment = upload_file :filename => '/files/rails.jpg'
+      attachment = upload_file :filename => '/files/rails.jpg', :content_type => 'image/jpeg'
       lq_size = attachment.size
-      puts "FULL: #{full_size} - LQ: #{lq_size}"
       assert lq_size <= full_size * 0.9, 'Lower-quality JPEG filesize should be congruently smaller'
+
+      attachment_model ImageWithPerThumbJpegAttachment
+      attachment = upload_file :filename => '/files/rails.jpg', :content_type => 'image/jpeg'
+      assert_file_jpeg_quality attachment, :thumb, 90
+      assert_file_jpeg_quality attachment, :avatar, 85
+      assert_file_jpeg_quality attachment, :large, 75
+      assert_file_jpeg_quality attachment, nil, 75
     end
   else
     def test_flunk

data/test/schema.rb

@@ -2,6 +2,8 @@ ActiveRecord::Schema.define(:version => 0) do
   create_table :attachments, :force => true do |t|
     t.column :db_file_id,      :integer
     t.column :parent_id,       :integer
+    t.column :imageable_id,    :integer
+    t.column :imageable_type,  :string, :limit => 255
     t.column :thumbnail,       :string
     t.column :filename,        :string, :limit => 255
     t.column :content_type,    :string, :limit => 255

data/test/test_helper.rb

@@ -84,7 +84,9 @@ class Test::Unit::TestCase #:nodoc:
   protected
     def upload_file(options = {})
       use_temp_file options[:filename] do |file|
-        att = attachment_model.create :uploaded_data => fixture_file_upload(file, options[:content_type] || 'image/png')
+        opts = { :uploaded_data => fixture_file_upload(file, options[:content_type] || 'image/png') }
+        opts.update(options.reject { |k, v| ![:imageable_type, :imageable_id].include?(k) })
+        att = attachment_model.create opts
         att.reload unless att.new_record?
         return att
       end
@@ -119,6 +121,27 @@ class Test::Unit::TestCase #:nodoc:
       end
     end
     
+    def assert_file_jpeg_quality(model, thumbnail, expected)
+      filename = if model.respond_to?(:full_filename)
+        model.full_filename(thumbnail)
+      else
+        thumb = thumbnail ? model.thumbnails.find(:first, :conditions => { :thumbnail => thumbnail.to_s }, :include => :db_file) : model
+        unless thumb && thumb.db_file && thumb.db_file.data && thumb.db_file.data.size > 0
+          STDERR.puts "Cannot find DB file data for thumbnail #{thumbnail.inspect} -> Aborting JPEG quality check."
+          return
+        end
+        result = Tempfile.new('dbfile_dump').path
+        File.open(result, 'wb') { |f| f.write(thumb.db_file.data) }
+        result
+      end
+      quality = %x(identify -format '%Q' "#{filename}" 2> /dev/null)
+      if $?.success?
+        assert_equal expected, quality.to_i, "Produced JPEG quality (thumbnail: #{thumbnail.inspect}) is incorrect."
+      else
+        STDERR.puts "ImageMagick's identify not found / not in PATH: can't quickly check produced image quality."
+      end
+    end
+    
     def assert_not_created
       assert_created(0) { yield }
     end

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: tdd-attachment_fu
 version: !ruby/object:Gem::Version 
-  version: 0.9.6
+  prerelease: true
+  segments: 
+  - 0
+  - 9
+  - 9
+  - b
+  version: 0.9.9.b
 platform: ruby
 authors: 
 - Rick Olson
@@ -10,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-04 00:00:00 -07:00
+date: 2010-03-15 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -73,7 +79,8 @@ files:
 - vendor/red_artisan/core_image/filters/watermark.rb
 has_rdoc: true
 homepage: http://github.com/tdd/attachment_fu
-licenses: 
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --inline-source
@@ -84,18 +91,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
-rubyforge_project: attachment_fu
-rubygems_version: 1.3.5
+rubyforge_project: 
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 2
 summary: attachment_fu with more geometries, polymorphic-based settings and JPEG quality control.