attachment_saver 1.0.0

data/lib/datastores/in_column.rb

@@ -0,0 +1,49 @@
+require 'attachment_saver_errors'
+
+class InColumnAttachmentDatastoreError < AttachmentDataStoreError; end
+
+module AttachmentSaver
+  module DataStores
+    module InColumn
+      def self.included(base)
+        base.attachment_options[:column_name] ||= 'data'
+        base.attachment_options[:temp_directory] ||= Dir.tmpdir
+      end
+      
+      def save_attachment
+        return unless @save_upload # this method is called every time the model is saved, not just when a new file has been uploaded
+
+        send("#{self.class.attachment_options[:column_name]}=", uploaded_data)
+
+        save_temporary_and_process_attachment if process_attachment?
+
+        @save_upload = nil
+      end
+      
+      def   tidy_attachment; end
+      def delete_attachment; end # delete_attachment is used when the record is deleted, so we don't need to do anything
+      
+      def in_storage?
+        !send(self.class.attachment_options[:column_name]).nil?
+      end
+      
+      # there is no public_path, since you need to make a controller to pull the blob from the database
+
+      def reprocess!
+        raise "this attachment already has a file open to process" unless uploaded_file.nil?
+        save_temporary_and_process_attachment
+        save!
+      end
+      
+      def save_temporary_and_process_attachment
+        FileUtils.mkdir_p(self.class.attachment_options[:temp_directory])
+        Tempfile.open("asctemp", self.class.attachment_options[:temp_directory]) do |temp|
+          temp.binmode
+          temp.write(send(self.class.attachment_options[:column_name]))
+          temp.flush
+          process_attachment_with_wrapping(temp.path)
+        end
+      end
+    end
+  end
+end

data/lib/misc/extended_tempfile.rb

@@ -0,0 +1,12 @@
+require 'tempfile'
+
+class ExtendedTempfile < Tempfile
+  def initialize(basename, tmpdir = Dir.tmpdir, extension = '')
+    @extension = extension
+    super(basename, tmpdir)
+  end
+  
+  def make_tmpname(basename, n)
+    sprintf('%s.%d.%d.%s', basename, $$, n || 0, @extension)
+  end
+end

data/lib/misc/file_size.rb

@@ -0,0 +1,5 @@
+class File
+  def size # for compatibility with StringIO & Tempfile
+    stat.size
+  end
+end

data/lib/misc/image_science_extensions.rb

@@ -0,0 +1,102 @@
+require 'image_science'
+
+class ImageScience
+  # TODO: submit a patch to image_science calling the built-in freeimage functions instead of using these lists
+  
+  # from freeimage.h
+  FIF_UNKNOWN = -1;
+	FIF_BMP		  = 0;
+	FIF_ICO		  = 1;
+	FIF_JPEG	  = 2;
+	FIF_JNG		  = 3;
+	FIF_KOALA	  = 4;
+	FIF_LBM	  	= 5;
+	FIF_IFF     = FIF_LBM;
+	FIF_MNG		  = 6;
+	FIF_PBM		  = 7;
+	FIF_PBMRAW	= 8;
+	FIF_PCD		  = 9;
+	FIF_PCX		  = 10;
+	FIF_PGM		  = 11;
+	FIF_PGMRAW	= 12;
+	FIF_PNG		  = 13;
+	FIF_PPM		  = 14;
+	FIF_PPMRAW	= 15;
+	FIF_RAS		  = 16;
+	FIF_TARGA	  = 17;
+	FIF_TIFF	  = 18;
+	FIF_WBMP	  = 19;
+	FIF_PSD		  = 20;
+	FIF_CUT		  = 21;
+	FIF_XBM		  = 22;
+	FIF_XPM		  = 23;
+	FIF_DDS		  = 24;
+	FIF_GIF     = 25;
+  FIF_HDR     = 26;
+  FIF_FAXG3   = 27;
+  FIF_SGI     = 28;
+	
+  FILE_TYPES = {
+    # from the documentation
+  	FIF_BMP		  => 'BMP',
+  	FIF_ICO		  => 'ICO',
+  	FIF_JPEG	  => 'JPG',
+  	FIF_JNG		  => 'JNG',
+  	FIF_KOALA	  => 'KOA',
+  	FIF_LBM	  	=> 'LBM',
+  	FIF_MNG		  => 'MNG',
+  	FIF_PBM		  => 'PBM',
+  	FIF_PBMRAW	=> 'PBM',
+  	FIF_PCD		  => 'PCD',
+  	FIF_PCX		  => 'PCX',
+  	FIF_PGM		  => 'PGM',
+  	FIF_PGMRAW	=> 'PGM',
+  	FIF_PNG		  => 'PNG',
+  	FIF_PPM		  => 'PPM',
+  	FIF_PPMRAW	=> 'PPM',
+  	FIF_RAS		  => 'RAS',
+  	FIF_TARGA	  => 'TGA',
+  	FIF_TIFF	  => 'TIFF',
+  	FIF_WBMP	  => 'WBMP',
+  	FIF_PSD		  => 'PSD',
+  	FIF_CUT		  => 'CUT',
+  	FIF_XBM		  => 'XBM',
+  	FIF_XPM		  => 'XPM',
+  	FIF_DDS		  => 'DDS',
+  	FIF_GIF     => 'GIF',
+    FIF_HDR     => 'HDR',
+    FIF_FAXG3   => 'G3',
+    FIF_SGI     => 'SGI'
+  }
+	
+	MIME_TYPES = {
+	  # we only list the standardised MIME types here, leaving out any freeimage invented (ie. all the image/freeimage-* values)
+  	FIF_BMP		  => 'image/bmp',
+  	FIF_ICO		  => 'image/x-icon',
+  	FIF_JPEG	  => 'image/jpeg',
+  	FIF_MNG		  => 'video/x-mng',
+  	FIF_PCD		  => 'image/x-photo-cd',
+  	FIF_PCX		  => 'image/x-pcx',
+  	FIF_PNG		  => 'image/png',
+  	FIF_RAS		  => 'image/x-cmu-raster',
+  	FIF_TIFF	  => 'image/tiff',
+  	FIF_WBMP	  => 'image/vnd.wap.wbmp',
+  	FIF_XBM		  => 'image/x-xbitmap',
+  	FIF_XPM		  => 'image/xpm',
+  	FIF_GIF     => 'image/gif',
+    FIF_FAXG3   => 'image/fax-g3',
+    FIF_SGI     => 'image/sgi'
+	}
+  
+  # determines the file format of this image file (represented as an uppercase string).
+  # nil if the file type is not known, or if no image has been loaded.
+  def file_type
+    FILE_TYPES[@file_type]
+  end
+  
+  # determines the MIME type of this image file.
+  # nil if the file type is not known, or if no image has been loaded.
+  def mime_type
+    MIME_TYPES[@file_type]
+  end
+end

data/lib/misc/mini_magick_extensions.rb

@@ -0,0 +1,89 @@
+require 'mini_magick'
+
+class MiniMagick::Image
+  MIME_TYPES = {
+    'BMP' => 'image/bmp',
+    'CUR' => 'image/x-win-bitmap',
+    'DCX' => 'image/dcx',
+    'EPDF' => 'application/pdf',
+    'EPI' => 'application/postscript',
+    'EPS' => 'application/postscript',
+    'EPSF' => 'application/postscript',
+    'EPSI' => 'application/postscript',
+    'EPT' => 'application/postscript',
+    'EPT2' => 'application/postscript',
+    'EPT3' => 'application/postscript',
+    'FAX' => 'image/g3fax',
+    'FITS' => 'image/x-fits',
+    'G3' => 'image/g3fax',
+    'GIF' => 'image/gif',
+    'GIF87' => 'image/gif',
+    'ICB' => 'application/x-icb',
+    'ICO' => 'image/x-win-bitmap',
+    'ICON' => 'image/x-win-bitmap',
+    'JNG' => 'image/jng',
+    'JPEG' => 'image/jpeg',
+    'JPG' => 'image/jpeg',
+    'M2V' => 'video/mpeg2',
+    'MIFF' => 'application/x-mif',
+    'MNG' => 'video/mng',
+    'MPEG' => 'video/mpeg',
+    'MPG' => 'video/mpeg',
+    'OTB' => 'image/x-otb',
+    'PALM' => 'image/x-palm',
+    'PBM' => 'image/pbm',
+    'PCD' => 'image/pcd',
+    'PCDS' => 'image/pcd',
+    'PCL' => 'application/pcl',
+    'PCT' => 'image/pict',
+    'PCX' => 'image/x-pcx',
+    'PDB' => 'application/vnd.palm',
+    'PDF' => 'application/pdf',
+    'PGM' => 'image/x-pgm',
+    'PICON' => 'image/xpm',
+    'PICT' => 'image/pict',
+    'PJPEG' => 'image/pjpeg',
+    'PNG' => 'image/png',
+    'PNG24' => 'image/png',
+    'PNG32' => 'image/png',
+    'PNG8' => 'image/png',
+    'PNM' => 'image/pbm',
+    'PPM' => 'image/x-ppm',
+    'PS' => 'application/postscript',
+    'PSD' => 'image/x-photoshop',
+    'PTIF' => 'image/x-ptiff',
+    'RAS' => 'image/ras',
+    'SGI' => 'image/sgi',
+    'SUN' => 'image/ras',
+    'SVG' => 'image/svg+xml',
+    'SVGZ' => 'image/svg',
+    'TEXT' => 'text/plain',
+    'TGA' => 'image/tga',
+    'TIF' => 'image/tiff',
+    'TIFF' => 'image/tiff',
+    'TXT' => 'text/plain',
+    'VDA' => 'image/vda',
+    'VIFF' => 'image/x-viff',
+    'VST' => 'image/vst',
+    'WBMP' => 'image/vnd.wap.wbmp',
+    'XBM' => 'image/x-xbitmap',
+    'XPM' => 'image/x-xbitmap',
+    'XV' => 'image/x-viff',
+    'XWD' => 'image/xwd',
+  }
+
+  # determines the MIME type of this image file.
+  # nil if the file type is not known, or if no image has been loaded.
+  def mime_type
+    MIME_TYPES[format]
+  end
+  
+  # creates an independent copy of the file.
+  def dup
+    if ::MiniMagick::Image.respond_to?(:read) # v3
+      self.class.read(to_blob)
+    else # v1
+      self.class.from_blob(to_blob, File.extname(path))
+    end
+  end
+end

data/lib/processors/image.rb

@@ -0,0 +1,187 @@
+require 'attachment_saver_errors'
+
+class ImageProcessorError < AttachmentProcessorError; end
+
+module AttachmentSaver
+  module Processors
+    # shared code for all image processors
+    module Image
+      def image?
+        return false if content_type.blank?
+        parts = content_type.split(/\//)
+        parts.size == 2 && parts.first.strip == 'image'
+      end
+      
+      def before_validate_attachment
+        examine_attachment unless uploaded_file.nil? || derived_image?
+      rescue ImageProcessorError
+        # we examine all files, regardless of whether the client browser labelled them an
+        # image, because they may be an image with the wrong extension or content type.
+        # but this will raise for non-image files, so ignore such errors but make sure
+        # image? will return false, if it doesn't already.
+        self.content_type = "application/octet-stream" if image?
+      end
+
+      def process_attachment?
+        image? && !self.class.attachment_options[:formats].blank? && !derived_image?
+      end
+      
+      # determines if this is a derived image.  used to prevent infinite recursion when 
+      # storing the derived images in the same model as the originals (and as a secondary
+      # benefit avoid unnecessary work examining images for derived images, for which the
+      # full metadata is already filled in by the resizing code).
+      def derived_image?
+        respond_to?(:format_name) && !format_name.blank?
+      end
+      
+      # determines if a particular configured derived image should be created.  this
+      # implementation, which always returns true, may be overridden by applications to make
+      # certain formats conditional (for example, only creating certain larger sizes if the 
+      # original image was at least that large).
+      def want_format?(derived_name, derived_width, derived_height)
+        true
+      end
+
+      def process_attachment(filename)
+        with_image(filename) do |original_image|
+          unless self.class.attachment_options[:formats].blank?
+            old_children = new_record? ? {} : formats.group_by(&:format_name)
+            self.class.attachment_options[:formats].each do |derived_name, resize_format|
+              derived_attributes = process_image(original_image, derived_name, resize_format)
+              if derived_attributes
+                if old_children[derived_name.to_s]
+                  update_derived(old_children[derived_name.to_s].pop, derived_attributes)
+                else
+                  build_derived(derived_attributes)
+                end
+              end
+            end
+            old_children = old_children.values.flatten
+            formats.destroy(old_children) unless old_children.blank? # remove any old derived images for formats for which want_format? now returned false
+          end
+        end
+      rescue AttachmentSaverError
+        raise
+      rescue Exception => ex
+        raise ImageProcessorError, "#{ex.class}: #{ex.message}", ex.backtrace
+      end
+      
+      # builds a new derived image model instance, but doesn't save it.
+      # provided so apps can easily override this step.
+      def build_derived(attributes)
+        formats.build(attributes)
+      end
+      
+      # updates an existing derived image model instance, and queues it for save when this
+      # model is saved.  provided so apps can easily override this step.
+      def update_derived(derived, attributes)
+        derived.attributes = attributes
+        @updated_derived_children ||= []
+        @updated_derived_children << derived # we don't want to save it just yet in case processing subsequent images fail; rails will automatically save it if we're a new record, but we have to do it ourselves in an after_save if not
+        derived
+      end
+      
+      # unpacks a resize geometry string into an array contining the corresponding image
+      # operation method name (see Operations below, plus any from your chosen image processor)
+      # followed by the arguments to that method.
+      def self.from_geometry_string(geom)
+        match, w, cross, h, flag = geom.match(/^(\d+\.?\d*)?(?:([xX])(\d+\.?\d*)?)?([!%<>#*])?$/).to_a
+        raise "couldn't parse geometry string '#{geom}'" if match.nil? || (w.nil? && h.nil?)
+        h = w unless cross # there's <w>x<h>, there's <w>x, there's x<h>, and then there's just plain <n>, which means <w>=<h>=<n>
+        return [:scale_by, (w || h).to_f/100, (h || w).to_f/100] if flag == '%'
+        operation = case flag
+          when nil then :scale_to_fit
+          when '!' then w && h ? :squish : :scale_to_fit
+          when '>' then :shrink_to_fit
+          when '<' then :expand_to_fit
+          when '*' then :scale_to_cover
+          when '#' then :cover_and_crop
+        end
+        [operation, w ? w.to_i : nil, h ? h.to_i : nil]
+      end
+      
+      module Operations
+        # if they choose to use this module to implement the resize operations, the processor
+        # module just needs to implement width, height, resize_to(new_width, new_height, &block),
+        # and crop_to(new_width, new_height, &block)
+        
+        # squishes the image to the given width and height, without preserving the aspect ratio.
+        # yields this image itself if it is already the given size.
+        def squish(new_width, new_height, &block)
+          return block.call(self) if new_width == width && new_height == height
+          resize_to(new_width.to_i, new_height.to_i, &block)
+        end
+        
+        # scales the image by the given factors.
+        def scale_by(width_factor, height_factor, &block)
+          squish(width*width_factor, height*height_factor, &block)
+        end
+        
+        # calculates the appropriate dimensions for scale_to_fit.
+        def scale_dimensions_to_fit(new_width, new_height)
+          raise ArgumentError, "must supply the width and/or height" if new_width.nil? && new_height.nil?
+          if new_height.nil? || (!new_width.nil? && height*new_width < width*new_height)
+            return [new_width, height*new_width/width]
+          else
+            return [width*new_height/height, new_height]
+          end
+        end
+        
+        # scales the image proportionately so that it fits within the given width and height
+        # (ie. one dimension will be equal to the given dimension, and the other dimension
+        # will be smaller than the given other dimension).  either (but not both) of the new
+        # width & height may be nil, in which case the image will be scaled solely based on
+        # the other parameter.  yields this image itself if it is already the appropriate size.
+        def scale_to_fit(new_width, new_height, &block)
+          squish(*scale_dimensions_to_fit(new_width, new_height), &block)
+        end
+        
+        # keeps proportions, as for scale_to_fit, but only ever makes images smaller.
+        # yields this image itself if it is already within the given dimensions.
+        def shrink_to_fit(new_width, new_height, &block)
+          new_width, new_height = scale_dimensions_to_fit(new_width, new_height)
+          return block.call(self) if new_width >= width && new_height >= height
+          squish(new_width, new_height, &block)
+        end
+        
+        # keeps proportions, as for scale_to_fit, but only ever makes images bigger.
+        # yields this image itself if it is already within the given dimensions or if the
+        # scaled dimensions would be smaller than the current dimensions.
+        # this is one of the operations specified by the *magick geometry strings, but
+        # IMHO it's not particularly useful as it doesn't establish any particularly helpful
+        # postconditions; consider whether scale_to_cover would be more appropriate.
+        def expand_to_fit(new_width, new_height, &block)
+          new_width, new_height = scale_dimensions_to_fit(new_width, new_height)
+          return block.call(self) if new_width <= width && new_height <= height
+          squish(new_width, new_height, &block)
+        end
+        
+        # scales the image proportionately so that it fits over the given width and height (ie.
+        # one dimension will be equal to the given dimension, and the other dimension will be
+        # larger than the given other dimension).  either (but not both) of the new width & 
+        # height may be nil, in which case the image will be scaled solely based on the other
+        # parameter (in this case the result is the same as using scale_to_fit).
+        # yields this image itself if it is already the appropriate size.
+        def scale_to_cover(new_width, new_height, &block)
+          raise ArgumentError, "must supply the width and/or height" if new_width.nil? && new_height.nil?
+          if new_height.nil? || (!new_width.nil? && height*new_width > width*new_height)
+            squish(new_width, height*new_width/width, &block)
+          else
+            squish(width*new_height/height, new_height, &block)
+          end
+        end
+        # haven't seen any reason to implement shrink_to_cover and expand_to_cover yet, but could.
+        
+        # scales the image proportionately to fit over the given width and height (as for
+        # scale_to_cover), then crops the image to the given width & height.
+        # yields this image itself if it is already the appropriate size.
+        def cover_and_crop(new_width, new_height, &block)
+          scale_to_cover(new_width, new_height) do |scaled|
+            return block.call(scaled) if new_width == scaled.width && new_height == scaled.height
+            scaled.crop_to(new_width || width, new_height || height, &block)
+          end
+        end
+      end
+    end
+  end
+end