futuresinc-attachment_fu 1.0.4 → 1.0.5

data/lib/attachment_fu/backends/s3_backend.rb

@@ -0,0 +1,392 @@
+module AttachmentFu # :nodoc:
+  module Backends
+    # = AWS::S3 Storage Backend
+    #
+    # Enables use of {Amazon's Simple Storage Service}[http://aws.amazon.com/s3] as a storage mechanism
+    #
+    # == Requirements
+    #
+    # Requires the {AWS::S3 Library}[http://amazon.rubyforge.org] for S3 by Marcel Molina Jr. installed either
+    # as a gem or a as a Rails plugin.
+    #
+    # == Configuration
+    #
+    # Configuration is done via <tt>RAILS_ROOT/config/amazon_s3.yml</tt> and is loaded according to the <tt>RAILS_ENV</tt>.
+    # The minimum connection options that you must specify are a bucket name, your access key id and your secret access key.
+    # If you don't already have your access keys, all you need to sign up for the S3 service is an account at Amazon.
+    # You can sign up for S3 and get access keys by visiting http://aws.amazon.com/s3.
+    #
+    # If you wish to use Amazon CloudFront to serve the files, you can also specify a distibution domain for the bucket.
+    # To read more about CloudFront, visit http://aws.amazon.com/cloudfront
+    #
+    # Example configuration (RAILS_ROOT/config/amazon_s3.yml)
+    #
+    #   development:
+    #     bucket_name: appname_development
+    #     access_key_id: <your key>
+    #     secret_access_key: <your key>
+    #     distribution_domain: XXXX.cloudfront.net
+    #
+    #   test:
+    #     bucket_name: appname_test
+    #     access_key_id: <your key>
+    #     secret_access_key: <your key>
+    #     distribution_domain: XXXX.cloudfront.net
+    #
+    #   production:
+    #     bucket_name: appname
+    #     access_key_id: <your key>
+    #     secret_access_key: <your key>
+    #     distribution_domain: XXXX.cloudfront.net
+    #
+    # You can change the location of the config path by passing a full path to the :s3_config_path option.
+    #
+    #   has_attachment :storage => :s3, :s3_config_path => (RAILS_ROOT + '/config/s3.yml')
+    #
+    # === Required configuration parameters
+    #
+    # * <tt>:access_key_id</tt> - The access key id for your S3 account. Provided by Amazon.
+    # * <tt>:secret_access_key</tt> - The secret access key for your S3 account. Provided by Amazon.
+    # * <tt>:bucket_name</tt> - A unique bucket name (think of the bucket_name as being like a database name).
+    #
+    # If any of these required arguments is missing, a MissingAccessKey exception will be raised from AWS::S3.
+    #
+    # == About bucket names
+    #
+    # Bucket names have to be globaly unique across the S3 system. And you can only have up to 100 of them,
+    # so it's a good idea to think of a bucket as being like a database, hence the correspondance in this
+    # implementation to the development, test, and production environments.
+    #
+    # The number of objects you can store in a bucket is, for all intents and purposes, unlimited.
+    #
+    # === Optional configuration parameters
+    #
+    # * <tt>:server</tt> - The server to make requests to. Defaults to <tt>s3.amazonaws.com</tt>.
+    # * <tt>:port</tt> - The port to the requests should be made on. Defaults to 80 or 443 if <tt>:use_ssl</tt> is set.
+    # * <tt>:use_ssl</tt> - If set to true, <tt>:port</tt> will be implicitly set to 443, unless specified otherwise. Defaults to false.
+    # * <tt>:distribution_domain</tt> - The CloudFront distribution domain for the bucket.  This can either be the assigned
+    #     distribution domain (ie. XXX.cloudfront.net) or a chosen domain using a CNAME. See CloudFront for more details.
+    #
+    # == Usage
+    #
+    # To specify S3 as the storage mechanism for a model, set the acts_as_attachment <tt>:storage</tt> option to <tt>:s3</tt>.
+    #
+    #   class Photo < ActiveRecord::Base
+    #     has_attachment :storage => :s3
+    #   end
+    #
+    # === Customizing the path
+    #
+    # By default, files are prefixed using a pseudo hierarchy in the form of <tt>:table_name/:id</tt>, which results
+    # in S3 urls that look like: http(s)://:server/:bucket_name/:table_name/:id/:filename with :table_name
+    # representing the customizable portion of the path. You can customize this prefix using the <tt>:path_prefix</tt>
+    # option:
+    #
+    #   class Photo < ActiveRecord::Base
+    #     has_attachment :storage => :s3, :path_prefix => 'my/custom/path'
+    #   end
+    #
+    # Which would result in URLs like <tt>http(s)://:server/:bucket_name/my/custom/path/:id/:filename.</tt>
+    #
+    # === Using different bucket names on different models
+    #
+    # By default the bucket name that the file will be stored to is the one specified by the
+    # <tt>:bucket_name</tt> key in the amazon_s3.yml file.  You can use the <tt>:bucket_key</tt> option
+    # to overide this behavior on a per model basis.  For instance if you want a bucket that will hold
+    # only Photos you can do this:
+    #
+    #   class Photo < ActiveRecord::Base
+    #     has_attachment :storage => :s3, :bucket_key => :photo_bucket_name
+    #   end
+    #
+    # And then your amazon_s3.yml file needs to look like this.
+    #
+    #   development:
+    #     bucket_name: appname_development
+    #     access_key_id: <your key>
+    #     secret_access_key: <your key>
+    #
+    #   test:
+    #     bucket_name: appname_test
+    #     access_key_id: <your key>
+    #     secret_access_key: <your key>
+    #
+    #   production:
+    #     bucket_name: appname
+    #     photo_bucket_name: appname_photos
+    #     access_key_id: <your key>
+    #     secret_access_key: <your key>
+    #
+    #  If the bucket_key you specify is not there in a certain environment then attachment_fu will
+    #  default to the <tt>bucket_name</tt> key.  This way you only have to create special buckets
+    #  this can be helpful if you only need special buckets in certain environments.
+    #
+    # === Permissions
+    #
+    # By default, files are stored on S3 with public access permissions. You can customize this using
+    # the <tt>:s3_access</tt> option to <tt>has_attachment</tt>. Available values are
+    # <tt>:private</tt>, <tt>:public_read_write</tt>, and <tt>:authenticated_read</tt>.
+    #
+    # === Other options
+    #
+    # Of course, all the usual configuration options apply, such as content_type and thumbnails:
+    #
+    #   class Photo < ActiveRecord::Base
+    #     has_attachment :storage => :s3, :content_type => ['application/pdf', :image], :resize_to => 'x50'
+    #     has_attachment :storage => :s3, :thumbnails => { :thumb => [50, 50], :geometry => 'x50' }
+    #   end
+    #
+    # === Accessing S3 URLs
+    #
+    # You can get an object's URL using the s3_url accessor. For example, assuming that for your postcard app
+    # you had a bucket name like 'postcard_world_development', and an attachment model called Photo:
+    #
+    #   @postcard.s3_url # => http(s)://s3.amazonaws.com/postcard_world_development/photos/1/mexico.jpg
+    #
+    # The resulting url is in the form: http(s)://:server/:bucket_name/:table_name/:id/:file.
+    # The optional thumbnail argument will output the thumbnail's filename (if any).
+    #
+    # Additionally, you can get an object's base path relative to the bucket root using
+    # <tt>base_path</tt>:
+    #
+    #   @photo.file_base_path # => photos/1
+    #
+    # And the full path (including the filename) using <tt>full_filename</tt>:
+    #
+    #   @photo.full_filename # => photos/
+    #
+    # Niether <tt>base_path</tt> or <tt>full_filename</tt> include the bucket name as part of the path.
+    # You can retrieve the bucket name using the <tt>bucket_name</tt> method.
+    # 
+    # === Accessing CloudFront URLs
+    # 
+    # You can get an object's CloudFront URL using the cloudfront_url accessor.  Using the example from above:
+    # @postcard.cloudfront_url # => http://XXXX.cloudfront.net/photos/1/mexico.jpg
+    #
+    # The resulting url is in the form: http://:distribution_domain/:table_name/:id/:file
+    #
+    # If you set :cloudfront to true in your model, the public_filename will be the CloudFront
+    # URL, not the S3 URL.
+    module S3Backend
+      class RequiredLibraryNotFoundError < StandardError; end
+      class ConfigFileNotFoundError < StandardError; end
+
+      def self.included(base) #:nodoc:
+        mattr_reader :bucket_name, :s3_config
+
+        begin
+          require 'aws/s3'
+          include AWS::S3
+        rescue LoadError
+          raise RequiredLibraryNotFoundError.new('AWS::S3 could not be loaded')
+        end
+
+        begin
+          @@s3_config_path = base.attachment_options[:s3_config_path] || (RAILS_ROOT + '/config/amazon_s3.yml')
+          @@s3_config = @@s3_config = YAML.load(ERB.new(File.read(@@s3_config_path)).result)[RAILS_ENV].symbolize_keys
+        #rescue
+        #  raise ConfigFileNotFoundError.new('File %s not found' % @@s3_config_path)
+        end
+
+        bucket_key = base.attachment_options[:bucket_key]
+
+        if bucket_key and s3_config[bucket_key.to_sym]
+          eval_string = "def bucket_name()\n  \"#{s3_config[bucket_key.to_sym]}\"\nend"
+        else
+          eval_string = "def bucket_name()\n  \"#{s3_config[:bucket_name]}\"\nend"
+        end
+        base.class_eval(eval_string, __FILE__, __LINE__)
+
+        Base.establish_connection!(s3_config.slice(:access_key_id, :secret_access_key, :server, :port, :use_ssl, :persistent, :proxy))
+
+        # Bucket.create(@@bucket_name)
+
+        base.before_update :rename_file
+      end
+
+      def self.protocol
+        @protocol ||= s3_config[:use_ssl] ? 'https://' : 'http://'
+      end
+
+      def self.hostname
+        @hostname ||= s3_config[:server] || AWS::S3::DEFAULT_HOST
+      end
+
+      def self.port_string
+        @port_string ||= (s3_config[:port].nil? || s3_config[:port] == (s3_config[:use_ssl] ? 443 : 80)) ? '' : ":#{s3_config[:port]}"
+      end
+      
+      def self.distribution_domain
+        @distribution_domain = s3_config[:distribution_domain]
+      end
+
+      module ClassMethods
+        def s3_protocol
+          AttachmentFu::Backends::S3Backend.protocol
+        end
+
+        def s3_hostname
+          AttachmentFu::Backends::S3Backend.hostname
+        end
+
+        def s3_port_string
+          AttachmentFu::Backends::S3Backend.port_string
+        end
+        
+        def cloudfront_distribution_domain
+          AttachmentFu::Backends::S3Backend.distribution_domain
+        end
+      end
+
+      # Overwrites the base filename writer in order to store the old filename
+      def filename=(value)
+        @old_filename = filename unless filename.nil? || @old_filename
+        write_attribute :filename, sanitize_filename(value)
+      end
+
+      # The attachment ID used in the full path of a file
+      def attachment_path_id
+        ((respond_to?(:parent_id) && parent_id) || id).to_s
+      end
+
+      # The pseudo hierarchy containing the file relative to the bucket name
+      # Example: <tt>:table_name/:id</tt>
+      def base_path
+        File.join(attachment_options[:path_prefix], attachment_path_id)
+      end
+
+      # The full path to the file relative to the bucket name
+      # Example: <tt>:table_name/:id/:filename</tt>
+      def full_filename(thumbnail = nil)
+        File.join(base_path, thumbnail_name_for(thumbnail))
+      end
+
+      # All public objects are accessible via a GET request to the S3 servers. You can generate a
+      # url for an object using the s3_url method.
+      #
+      #   @photo.s3_url
+      #
+      # The resulting url is in the form: <tt>http(s)://:server/:bucket_name/:table_name/:id/:file</tt> where
+      # the <tt>:server</tt> variable defaults to <tt>AWS::S3 URL::DEFAULT_HOST</tt> (s3.amazonaws.com) and can be
+      # set using the configuration parameters in <tt>RAILS_ROOT/config/amazon_s3.yml</tt>.
+      #
+      # The optional thumbnail argument will output the thumbnail's filename (if any).
+      def s3_url(thumbnail = nil)
+        File.join(s3_protocol + s3_hostname + s3_port_string, bucket_name, full_filename(thumbnail))
+      end
+      
+      # All public objects are accessible via a GET request to CloudFront. You can generate a
+      # url for an object using the cloudfront_url method.
+      #
+      #   @photo.cloudfront_url
+      #
+      # The resulting url is in the form: <tt>http://:distribution_domain/:table_name/:id/:file</tt> using
+      # the <tt>:distribution_domain</tt> variable set in the configuration parameters in <tt>RAILS_ROOT/config/amazon_s3.yml</tt>.
+      #
+      # The optional thumbnail argument will output the thumbnail's filename (if any).
+      def cloudfront_url(thumbnail = nil)
+        "http://" + cloudfront_distribution_domain + "/" + full_filename(thumbnail)
+      end
+      
+      def public_filename(*args)
+        if attachment_options[:cloudfront]
+          cloudfront_url(args)
+        else
+          s3_url(args)
+        end
+      end
+
+      # All private objects are accessible via an authenticated GET request to the S3 servers. You can generate an
+      # authenticated url for an object like this:
+      #
+      #   @photo.authenticated_s3_url
+      #
+      # By default authenticated urls expire 5 minutes after they were generated.
+      #
+      # Expiration options can be specified either with an absolute time using the <tt>:expires</tt> option,
+      # or with a number of seconds relative to now with the <tt>:expires_in</tt> option:
+      #
+      #   # Absolute expiration date (October 13th, 2025)
+      #   @photo.authenticated_s3_url(:expires => Time.mktime(2025,10,13).to_i)
+      #
+      #   # Expiration in five hours from now
+      #   @photo.authenticated_s3_url(:expires_in => 5.hours)
+      #
+      # You can specify whether the url should go over SSL with the <tt>:use_ssl</tt> option.
+      # By default, the ssl settings for the current connection will be used:
+      #
+      #   @photo.authenticated_s3_url(:use_ssl => true)
+      #
+      # Finally, the optional thumbnail argument will output the thumbnail's filename (if any):
+      #
+      #   @photo.authenticated_s3_url('thumbnail', :expires_in => 5.hours, :use_ssl => true)
+      def authenticated_s3_url(*args)
+        options   = args.extract_options!
+        options[:expires_in] = options[:expires_in].to_i if options[:expires_in]
+        thumbnail = args.shift
+        S3Object.url_for(full_filename(thumbnail), bucket_name, options)
+      end
+
+      def create_temp_file
+        write_to_temp_file current_data
+      end
+
+      def current_data
+        S3Object.value full_filename, bucket_name
+      end
+
+      def s3_protocol
+        AttachmentFu::Backends::S3Backend.protocol
+      end
+
+      def s3_hostname
+        AttachmentFu::Backends::S3Backend.hostname
+      end
+
+      def s3_port_string
+        AttachmentFu::Backends::S3Backend.port_string
+      end
+      
+      def cloudfront_distribution_domain
+        AttachmentFu::Backends::S3Backend.distribution_domain
+      end
+
+      protected
+        # Called in the after_destroy callback
+        def destroy_file
+          S3Object.delete full_filename, bucket_name
+        end
+
+        def rename_file
+          return unless @old_filename && @old_filename != filename
+
+          old_full_filename = File.join(base_path, @old_filename)
+
+          S3Object.rename(
+            old_full_filename,
+            full_filename,
+            bucket_name,
+            :access => attachment_options[:s3_access]
+          )
+
+          @old_filename = nil
+          true
+        end
+
+        def save_to_storage
+          if save_attachment?
+            S3Object.store(
+              full_filename,
+              (temp_path ? File.open(temp_path) : temp_data),
+              bucket_name,
+              :content_type => content_type,
+              :access => attachment_options[:s3_access]
+            )
+          end
+
+          @old_filename = nil
+          true
+        end
+    end
+  end
+end

data/lib/attachment_fu/processors/core_image_processor.rb

@@ -0,0 +1,55 @@
+require 'red_artisan/core_image/processor'
+
+module AttachmentFu # :nodoc:
+  module Processors
+    module CoreImageProcessor
+      def self.included(base)
+        base.send :extend, ClassMethods
+        base.alias_method_chain :process_attachment, :processing
+      end
+      
+      module ClassMethods
+        def with_image(file, &block)
+          block.call OSX::CIImage.from(file)
+        end
+      end
+              
+      protected
+        def process_attachment_with_processing
+          return unless process_attachment_without_processing
+          with_image do |img|
+            self.width  = img.extent.size.width  if respond_to?(:width)
+            self.height = img.extent.size.height if respond_to?(:height)
+            resize_image_or_thumbnail! img
+            callback_with_args :after_resize, img
+          end if image?
+        end
+
+        # Performs the actual resizing operation for a thumbnail
+        def resize_image(img, size)
+          processor = ::RedArtisan::CoreImage::Processor.new(img)
+          size = size.first if size.is_a?(Array) && size.length == 1
+          if size.is_a?(Fixnum) || (size.is_a?(Array) && size.first.is_a?(Fixnum))
+            if size.is_a?(Fixnum)
+              processor.fit(size)
+            else
+              processor.resize(size[0], size[1])
+            end
+          else
+            new_size = [img.extent.size.width, img.extent.size.height] / size.to_s
+            processor.resize(new_size[0], new_size[1])
+          end
+          
+          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
+            temp_paths.unshift Tempfile.new(random_tempfile_filename, AttachmentFu.tempfile_path).path
+            result.save self.temp_path, OSX::NSJPEGFileType
+            self.size = File.size(self.temp_path)
+          end
+        end          
+    end
+  end
+end

data/lib/attachment_fu/processors/gd2_processor.rb

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'gd2'
+
+module AttachmentFu # :nodoc:
+  module Processors
+    module Gd2Processor
+      def self.included(base)
+        base.send :extend, ClassMethods
+        base.alias_method_chain :process_attachment, :processing
+      end
+      
+      module ClassMethods
+        # Yields a block containing a GD2 Image for the given binary data.
+        def with_image(file, &block)
+          im = GD2::Image.import(file)
+          block.call(im)
+        end
+      end
+
+      protected
+        def process_attachment_with_processing
+          return unless process_attachment_without_processing && image?
+          with_image do |img|
+            resize_image_or_thumbnail! img
+            self.width  = img.width
+            self.height = img.height
+            callback_with_args :after_resize, img
+          end
+        end
+
+        # Performs the actual resizing operation for a thumbnail
+        def resize_image(img, size)
+          size = size.first if size.is_a?(Array) && size.length == 1
+          if size.is_a?(Fixnum) || (size.is_a?(Array) && size.first.is_a?(Fixnum))
+            if size.is_a?(Fixnum)
+              # Borrowed from image science's #thumbnail method and adapted 
+              # for this.
+              scale = size.to_f / (img.width > img.height ? img.width.to_f : img.height.to_f)
+              img.resize!((img.width * scale).round(1), (img.height * scale).round(1), false)
+            else
+              img.resize!(size.first, size.last, false) 
+            end
+          else
+            w, h = [img.width, img.height] / size.to_s
+            img.resize!(w, h, false)
+          end
+          temp_paths.unshift random_tempfile_filename
+          self.size = img.export(self.temp_path)
+        end
+
+    end
+  end
+end

data/lib/attachment_fu/processors/image_science_processor.rb

@@ -0,0 +1,60 @@
+require 'image_science'
+
+module AttachmentFu # :nodoc:
+  module Processors
+    module ImageScienceProcessor
+      def self.included(base)
+        base.send :extend, ClassMethods
+        base.alias_method_chain :process_attachment, :processing
+      end
+
+      module ClassMethods
+        # Yields a block containing an Image Science image for the given binary data.
+        def with_image(file, &block)
+          ::ImageScience.with_image file, &block
+        end
+      end
+
+      protected
+        def process_attachment_with_processing
+          return unless process_attachment_without_processing && image?
+          with_image do |img|
+            self.width  = img.width  if respond_to?(:width)
+            self.height = img.height if respond_to?(:height)
+            resize_image_or_thumbnail! img
+          end
+        end
+
+        # Performs the actual resizing operation for a thumbnail
+        def resize_image(img, size)
+          # create a dummy temp file to write to
+          # ImageScience doesn't handle all gifs properly, so it converts them to
+          # pngs for thumbnails.  It has something to do with trying to save gifs
+          # with a larger palette than 256 colors, which is all the gif format
+          # supports.
+          filename.sub! /gif$/, 'png'
+          content_type.sub!(/gif$/, 'png')
+          temp_paths.unshift write_to_temp_file(filename)
+          grab_dimensions = lambda do |img|
+            self.width  = img.width  if respond_to?(:width)
+            self.height = img.height if respond_to?(:height)
+            img.save self.temp_path
+            self.size = File.size(self.temp_path)
+            callback_with_args :after_resize, img
+          end
+
+          size = size.first if size.is_a?(Array) && size.length == 1
+          if size.is_a?(Fixnum) || (size.is_a?(Array) && size.first.is_a?(Fixnum))
+            if size.is_a?(Fixnum)
+              img.thumbnail(size, &grab_dimensions)
+            else
+              img.resize(size[0], size[1], &grab_dimensions)
+            end
+          else
+            new_size = [img.width, img.height] / size.to_s
+            img.resize(new_size[0], new_size[1], &grab_dimensions)
+          end
+        end
+    end
+  end
+end

data/lib/attachment_fu/processors/mini_magick_processor.rb

@@ -0,0 +1,131 @@
+require 'mini_magick'
+
+module AttachmentFu # :nodoc:
+  module Processors
+    module MiniMagickProcessor
+      def self.included(base)
+        base.send :extend, ClassMethods
+        base.alias_method_chain :process_attachment, :processing
+      end
+
+      module ClassMethods
+        # Yields a block containing an MiniMagick Image for the given binary data.
+        def with_image(file, &block)
+          begin
+            binary_data = file.is_a?(MiniMagick::Image) ? file : MiniMagick::Image.from_file(file) unless !Object.const_defined?(:MiniMagick)
+          rescue
+            # Log the failure to load the image.
+            logger.debug("Exception working with image: #{$!}")
+            binary_data = nil
+          end
+          block.call binary_data if block && binary_data
+        ensure
+          !binary_data.nil?
+        end
+      end
+
+    protected
+      def process_attachment_with_processing
+        return unless process_attachment_without_processing
+        with_image do |img|
+          resize_image_or_thumbnail! img
+          self.width = img[:width] if respond_to?(:width)
+          self.height = img[:height] if respond_to?(:height)
+          callback_with_args :after_resize, img
+        end if image?
+      end
+
+      # Performs the actual resizing operation for a thumbnail
+      def resize_image(img, size)
+        size = size.first if size.is_a?(Array) && size.length == 1
+        img.combine_options do |commands|
+          commands.strip unless attachment_options[:keep_profile]
+
+          # gif are not handled correct, this is a hack, but it seems to work.
+          if img.output =~ / GIF /
+            img.format("png")
+          end           
+          
+          if size.is_a?(Fixnum) || (size.is_a?(Array) && size.first.is_a?(Fixnum))
+            if size.is_a?(Fixnum)
+              size = [size, size]
+              commands.resize(size.join('x'))
+            else
+              commands.resize(size.join('x') + '!')
+            end
+          # extend to thumbnail size
+          elsif size.is_a?(String) and size =~ /e$/
+            size = size.gsub(/e/, '')
+            commands.resize(size.to_s + '>')
+            commands.background('#ffffff')
+            commands.gravity('center')
+            commands.extent(size)
+          # crop thumbnail, the smart way
+          elsif size.is_a?(String) and size =~ /c$/
+             size = size.gsub(/c/, '')
+            
+            # calculate sizes and aspect ratio
+            thumb_width, thumb_height = size.split("x")
+            thumb_width   = thumb_width.to_f
+            thumb_height  = thumb_height.to_f
+            
+            thumb_aspect = thumb_width.to_f / thumb_height.to_f
+            image_width, image_height = img[:width].to_f, img[:height].to_f
+            image_aspect = image_width / image_height
+            
+            # only crop if image is not smaller in both dimensions
+            unless image_width < thumb_width and image_height < thumb_height
+              command = calculate_offset(image_width,image_height,image_aspect,thumb_width,thumb_height,thumb_aspect)
+
+              # crop image
+              commands.extract(command)
+            end
+
+            # don not resize if image is not as height or width then thumbnail
+            if image_width < thumb_width or image_height < thumb_height                   
+                commands.background('#ffffff')
+                commands.gravity('center')
+                commands.extent(size)
+            # resize image
+            else
+              commands.resize("#{size.to_s}")
+            end
+          # crop end
+          else
+            commands.resize(size.to_s)
+          end
+        end
+        temp_paths.unshift img
+      end
+
+      def calculate_offset(image_width,image_height,image_aspect,thumb_width,thumb_height,thumb_aspect)
+      # only crop if image is not smaller in both dimensions
+
+        # special cases, image smaller in one dimension then thumbsize
+        if image_width < thumb_width
+          offset = (image_height / 2) - (thumb_height / 2)
+          command = "#{image_width}x#{thumb_height}+0+#{offset}"
+        elsif image_height < thumb_height
+          offset = (image_width / 2) - (thumb_width / 2)
+          command = "#{thumb_width}x#{image_height}+#{offset}+0"
+
+        # normal thumbnail generation
+        # calculate height and offset y, width is fixed                 
+        elsif (image_aspect <= thumb_aspect or image_width < thumb_width) and image_height > thumb_height
+          height = image_width / thumb_aspect
+          offset = (image_height / 2) - (height / 2)
+          command = "#{image_width}x#{height}+0+#{offset}"
+        # calculate width and offset x, height is fixed
+        else
+          width = image_height * thumb_aspect
+          offset = (image_width / 2) - (width / 2)
+          command = "#{width}x#{image_height}+#{offset}+0"
+        end
+        # crop image
+        command
+      end
+
+
+    end
+  end
+end