jnicklas-carrierwave 0.1

data/lib/carrierwave/processing/rmagick.rb

@@ -0,0 +1,161 @@
+require 'rmagick'
+
+module CarrierWave
+  
+  ##
+  # This module simplifies manipulation with RMagick by providing a set
+  # of convenient helper methods. If you want to use them, you'll need to
+  # require this file
+  #
+  #     require 'carrierwave/processing/rmagick'
+  #
+  # And then include it in your uploader
+  #
+  #     MyUploade < CarrierWave::Uploader
+  #       include CarrierWave::RMagick
+  #     end
+  #
+  # You can now use the provided helpers:
+  #
+  #     MyUploade < CarrierWave::Uploader
+  #       include CarrierWave::RMagick
+  #       
+  #       process :resize_to_fit => [200, 200] 
+  #     end
+  #
+  # Or create your own helpers with the powerful manipulate! method. Check
+  # out the RMagick docs at http://www.imagemagick.org/RMagick/doc/ for more
+  # info
+  #
+  #     MyUploade < CarrierWave::Uploader
+  #       include CarrierWave::RMagick
+  #       
+  #       process :do_stuff => 10.0
+  #       
+  #       def do_stuff(blur_factor)
+  #         manipulate! do |img|
+  #           img = img.sepiatone
+  #           img = img.auto_orient
+  #           img = img.radial_blur(blur_factor)
+  #         end
+  #       end
+  #     end
+  #
+  module RMagick
+    
+    ##
+    # Changes the image encoding format to the given format
+    #
+    # @see http://www.imagemagick.org/RMagick/doc/magick.html#formats
+    # @param [#to_s] format an abreviation of the format
+    # @yieldparam [Magick::Image] img additional manipulations to perform
+    # @example
+    #     image.convert(:png)
+    # 
+    def convert(format)
+      manipulate! do |img|
+        img.format = format.to_s.upcase
+        img = yield(img) if block_given?
+        img
+      end
+    end
+
+    ##
+    # From the RMagick documentation: "Resize the image to fit within the
+    # specified dimensions while retaining the original aspect ratio. The
+    # image may be shorter or narrower than specified in the smaller dimension
+    # but will not be larger than the specified values."
+    #
+    # @see http://www.imagemagick.org/RMagick/doc/image3.html#resize_to_fit
+    #
+    # @param [Integer] width the width to scale the image to
+    # @param [Integer] height the height to scale the image to
+    # @yieldparam [Magick::Image] img additional manipulations to perform
+    # 
+    def resize_to_fit(width, height)
+      manipulate! do |img|
+        img.resize_to_fit!(width, height)
+        img = yield(img) if block_given?
+        img
+      end
+    end
+    
+    alias_method :resize, :resize_to_fit
+
+    ##
+    # From the RMagick documentation: "Resize the image to fit within the
+    # specified dimensions while retaining the aspect ratio of the original
+    # image. If necessary, crop the image in the larger dimension."
+    #
+    # @see http://www.imagemagick.org/RMagick/doc/image3.html#resize_to_fill
+    #
+    # @param [Integer] width the width to scale the image to
+    # @param [Integer] height the height to scale the image to
+    # @yieldparam [Magick::Image] img additional manipulations to perform
+    #
+    def resize_to_fill(width, height)
+      manipulate! do |img|
+        img.resize_to_fill!(width, height)
+        img = yield(img) if block_given?
+        img
+      end
+    end
+    
+    alias_method :crop_resized, :resize_to_fill
+    
+    ##
+    # Resize the image to fit within the specified dimensions while retaining
+    # the original aspect ratio. If necessary will pad the remaining area
+    # with the given color, which defaults to transparent (for gif and png,
+    # white for jpeg).
+    #
+    # @param [Integer] width the width to scale the image to
+    # @param [Integer] height the height to scale the image to
+    # @param [String, :transparent] background the color of the background as a hexcode, like "#ff45de"
+    # @param [Magick::GravityType] gravity how to position the image
+    # @yieldparam [Magick::Image] img additional manipulations to perform
+    #
+    def resize_and_pad(width, height, background=:transparent, gravity=::Magick::CenterGravity)
+      manipulate! do |img|
+        img.resize_to_fit!(width, height)
+        new_img = ::Magick::Image.new(width, height)
+        if background == :transparent
+          new_img = new_img.matte_floodfill(1, 1)
+        else
+          new_img = new_img.color_floodfill(1, 1, ::Magick::Pixel.from_color(background))
+        end
+        new_img = new_img.composite(img, gravity, ::Magick::OverCompositeOp)
+        new_img = yield(new_img) if block_given?
+        new_img
+      end
+    end
+
+    ##
+    # Manipulate the image with RMagick. This method will load up an image
+    # and then pass each of its frames to the supplied block. It will then
+    # save the image to disk.
+    #
+    # Note: This method assumes that the object responds to current_path
+    # any class that this is mixed into must have a current_path method.
+    #
+    # @yieldparam [Magick::Image] img manipulations to perform
+    # @raise [CarrierWave::ProcessingError] if manipulation failed.
+    #
+    def manipulate!
+      image = ::Magick::Image.read(current_path)
+
+      if image.size > 1
+        list = ::Magick::ImageList.new
+        image.each do |frame|
+          list << yield( frame )
+        end
+        list.write(current_path)
+      else
+        yield( image.first ).write(current_path)
+      end
+    rescue ::Magick::ImageMagickError => e
+      raise CarrierWave::ProcessingError.new("Failed to manipulate with rmagick, maybe it is not an image? Original Error: #{e}")
+    end   
+      
+  end # RMagick
+end # CarrierWave

data/lib/carrierwave/sanitized_file.rb

@@ -0,0 +1,231 @@
+module CarrierWave
+    class SanitizedFile
+
+    attr_accessor :file, :options
+
+    def initialize(file, options = {})
+      self.file = file
+      self.options = options
+    end
+
+    ##
+    # Returns the filename as is, without sanizting it.
+    #
+    # @return [String] the unsanitized filename
+    #
+    def original_filename
+      return @original_filename if @original_filename
+      if @file and @file.respond_to?(:original_filename)
+        @file.original_filename
+      elsif path
+        File.basename(path)
+      end
+    end
+  
+    ##
+    # Returns the filename, sanitized to strip out any evil characters.
+    #
+    # @return [String] the sanitized filename
+    #
+    def filename
+      sanitize(original_filename) if original_filename
+    end
+  
+    alias_method :identifier, :filename
+  
+    ##
+    # Returns the part of the filename before the extension. So if a file is called 'test.jpeg'
+    # this would return 'test'
+    #
+    # @return [String] the first part of the filename
+    #
+    def basename
+      split_extension(filename)[0] if filename
+    end
+  
+    ##
+    # Returns the file extension
+    #
+    # @return [String] the extension
+    #
+    def extension
+      split_extension(filename)[1] if filename
+    end
+
+    ##
+    # Returns the file's size.
+    #
+    # @return [Integer] the file's size in bytes.
+    #
+    def size
+      if @file.respond_to?(:size)
+        @file.size 
+      elsif path
+        File.size(path)
+      else 
+        0
+      end
+    end
+
+    ##
+    # Returns the full path to the file. If the file has no path, it will return nil.
+    #
+    # @return [String, nil] the path where the file is located.
+    #
+    def path
+      unless @file.blank?
+        if string?
+          File.expand_path(@file)
+        elsif @file.respond_to?(:path) and not @file.path.blank?
+          File.expand_path(@file.path)
+        end
+      end
+    end
+  
+    ##
+    # Returns true if the file is supplied as a pathname or as a string.
+    #
+    # @return [Boolean]
+    #
+    def string?
+      !!((@file.is_a?(String) || @file.is_a?(Pathname)) && !@file.blank?)
+    end
+
+    ##
+    # Checks if the file is valid and has a non-zero size
+    #
+    # @return [Boolean]
+    #
+    def empty?
+      (@file.nil? && @path.nil?) || self.size.nil? || self.size.zero?
+    end
+
+    ##
+    # Checks if the file exists
+    #
+    # @return [Boolean]
+    #
+    def exists?
+      return File.exists?(self.path) if self.path
+      return false
+    end
+  
+    ##
+    # Returns the contents of the file.
+    #
+    # @return [String] contents of the file
+    #
+    def read
+      if string?
+        File.read(@file)
+      else
+        @file.rewind if @file.respond_to?(:rewind)
+        @file.read
+      end
+    end
+
+    ##
+    # Moves the file to the given path
+    #
+    # @param [String] new_path The path where the file should be moved.
+    #
+    def move_to(new_path)
+      return if self.empty?
+      new_path = File.expand_path(new_path)
+
+      mkdir!(new_path)
+      if exists?
+        FileUtils.mv(path, new_path) unless new_path == path
+      else
+        File.open(new_path, "wb") { |f| f.write(read) }
+      end
+      chmod!(new_path)
+      self.file = new_path
+    end
+
+    ##
+    # Creates a copy of this file and moves it to the given path. Returns the copy.
+    #
+    # @param [String] new_path The path where the file should be copied to.
+    # @return [CarrierWave::SanitizedFile] the location where the file will be stored.
+    #
+    def copy_to(new_path)
+      return if self.empty?
+      new_path = File.expand_path(new_path)
+
+      mkdir!(new_path)
+      if exists?
+        FileUtils.cp(path, new_path) unless new_path == path
+      else
+        File.open(new_path, "wb") { |f| f.write(read) }
+      end
+      chmod!(new_path)
+      self.class.new(new_path)
+    end
+
+    ##
+    # Removes the file from the filesystem.
+    #
+    def delete
+      FileUtils.rm(self.path) if exists?
+    end
+
+    ##
+    # Returns the content type of the file.
+    #
+    # @return [String] the content type of the file 
+    #
+    def content_type
+      return @content_type if @content_type
+      @file.content_type.chomp if @file.respond_to?(:content_type) and @file.content_type
+    end
+
+  private
+  
+    def file=(file)
+      if file.is_a?(Hash)
+        @file = file["tempfile"]
+        @original_filename = file["filename"]
+        @content_type = file["content_type"]
+      else
+        @file = file
+        @original_filename = nil
+        @content_type = nil
+      end
+    end
+  
+    # create the directory if it doesn't exist
+    def mkdir!(path)
+      FileUtils.mkdir_p(File.dirname(path)) unless File.exists?(File.dirname(path))
+    end
+  
+    def chmod!(path)
+      File.chmod(@options[:permissions], path) if @options[:permissions]
+    end
+
+    # Sanitize the filename, to prevent hacking
+    def sanitize(name)
+      name = name.gsub("\\", "/") # work-around for IE
+      name = File.basename(name)
+      name = name.gsub(/[^a-zA-Z0-9\.\-\+_]/,"_")
+      name = "_#{name}" if name =~ /^\.+$/
+      name = "unnamed" if name.size == 0
+      return name.downcase
+    end
+
+    def split_extension(fn)
+      # regular expressions to try for identifying extensions
+      ext_regexps = [ 
+        /^(.+)\.([^\.]{1,3}\.[^\.]{1,4})$/, # matches "something.tar.gz"
+        /^(.+)\.([^\.]+)$/ # matches "something.jpg"
+      ]
+      ext_regexps.each do |regexp|
+        if fn =~ regexp
+          return $1, $2
+        end
+      end
+      return fn, "" # In case we weren't able to split the extension
+    end
+
+  end # SanitizedFile
+end # CarrierWave

data/lib/carrierwave/storage/abstract.rb

@@ -0,0 +1,80 @@
+module CarrierWave
+  module Storage
+    ##
+    # This file serves mostly as a specification for Storage engines. There is no requirement
+    # that storage engines must be a subclass of this class. However, any storage engine must
+    # conform to the following interface:
+    #
+    # The storage engine must respond to store!, taking an uploader object and a
+    # CarrierWave::SanitizedFile as parameters. This method should do something to store
+    # the given file, and then return an object.
+    #
+    # The storage engine must respond to retrieve!, taking an uploader object and an identifier
+    # as parameters. This method should do retrieve and then return an object.
+    #
+    # The objects returned by store! and retrieve! both *must* respond to +identifier+, taking
+    # no arguments. Identifier is a string that uniquely identifies this file and can be used
+    # to retrieve it later.
+    #
+    class Abstract
+      
+      ##
+      # Do setup specific for this storage engine
+      #
+      def self.setup!; end
+
+      ##
+      # Do something to store the file
+      #
+      # @param [CarrierWave::Uploader] uploader an uploader object
+      # @param [CarrierWave::SanitizedFile] file the file to store
+      #
+      # @return [#identifier] an object
+      #
+      def self.store!(uploader, file)
+        self.new
+      end
+      
+      # Do something to retrieve the file
+      #
+      # @param [CarrierWave::Uploader] uploader an uploader object
+      # @param [String] identifier uniquely identifies the file
+      #
+      # @return [#identifier] an object
+      #
+      def self.retrieve!(uploader, identifier)
+        self.new
+      end
+      
+      ##
+      # Should return a String that uniquely identifies this file and can be used to retrieve it from
+      # the same storage engine later on.
+      #
+      # This is OPTIONAL
+      #
+      # @return [String] path to the file
+      #
+      def identifier; end
+
+      ##
+      # Should return the url where the file is publically accessible. If this is not set, then
+      # it is assumed that the url is the path relative to the public directory.
+      #
+      # This is OPTIONAL
+      #
+      # @return [String] file's url
+      #
+      def url; end
+      
+      ##
+      # Should return the path where the file is corrently located. This is OPTIONAL.
+      #
+      # This is OPTIONAL
+      #
+      # @return [String] path to the file
+      #
+      def path; end
+      
+    end # Abstract
+  end # Storage
+end # CarrierWave

data/lib/carrierwave/storage/file.rb

@@ -0,0 +1,40 @@
+module CarrierWave
+  module Storage
+    class File < Abstract
+      
+      def initialize(uploader)
+        @uploader = uploader
+      end
+      
+      ##
+      # Move the file to the uploader's store path.
+      #
+      # @param [CarrierWave::Uploader] uploader an uploader object
+      # @param [CarrierWave::SanitizedFile] file the file to store
+      #
+      # @return [CarrierWave::SanitizedFile] a sanitized file
+      #
+      def self.store!(uploader, file)
+        path = ::File.join(uploader.store_dir, uploader.filename)
+        path = ::File.expand_path(path, uploader.root)
+        file.move_to(path)
+        file
+      end
+      
+      ##
+      # Retrieve the file from its store path
+      #
+      # @param [CarrierWave::Uploader] uploader an uploader object
+      # @param [String] identifier the filename of the file
+      #
+      # @return [CarrierWave::SanitizedFile] a sanitized file
+      #
+      def self.retrieve!(uploader, identifier)
+        path = ::File.join(uploader.store_dir, identifier)
+        path = ::File.expand_path(path, uploader.root)
+        CarrierWave::SanitizedFile.new(path)
+      end
+      
+    end # File
+  end # Storage
+end # CarrierWave

data/lib/carrierwave/storage/s3.rb

@@ -0,0 +1,83 @@
+module CarrierWave
+  module Storage
+    ##
+    # Uploads things to Amazon S3 webservices
+    #
+    class S3 < Abstract
+      
+      def initialize(bucket, store_dir, identifier)
+        @bucket = bucket
+        @store_dir = store_dir
+        @identifier = identifier
+      end
+      
+      ##
+      # Connect to Amazon S3
+      #
+      def self.setup!
+        require 'aws/s3'
+        AWS::S3::Base.establish_connection!(
+          :access_key_id     => CarrierWave.config[:s3][:access_key_id],
+          :secret_access_key => CarrierWave.config[:s3][:secret_access_key]
+        )
+      end
+      
+      ##
+      # @return [String] the bucket set in the config options
+      # 
+      def self.bucket
+        CarrierWave.config[:s3][:bucket]
+      end
+      
+      ##
+      # @return [Symbol] the access priviliges the uploaded files should have
+      #
+      def self.access
+        CarrierWave.config[:s3][:access]
+      end
+      
+      ##
+      # Store the file on S3
+      #
+      # @param [CarrierWave::Uploader] uploader an uploader object
+      # @param [CarrierWave::SanitizedFile] file the file to store
+      #
+      # @return [#identifier] an object
+      #
+      def self.store!(uploader, file)
+        AWS::S3::S3Object.store(::File.join(uploader.store_dir, uploader.filename), file.read, bucket, :access => access)
+        self.new(bucket, uploader.store_dir, uploader.filename)
+      end
+      
+      # Do something to retrieve the file
+      #
+      # @param [CarrierWave::Uploader] uploader an uploader object
+      # @param [String] identifier uniquely identifies the file
+      #
+      # @return [#identifier] an object
+      #
+      def self.retrieve!(uploader, identifier)
+        self.new(bucket, uploader.store_dir, identifier)
+      end
+      
+      ##
+      # Returns the filename on S3
+      #
+      # @return [String] path to the file
+      #
+      def identifier
+        @identifier
+      end
+
+      ##
+      # Returns the url on Amazon's S3 service
+      #
+      # @return [String] file's url
+      #
+      def url
+        "http://s3.amazonaws.com/#{self.class.bucket}/#{@store_dir}/#{@identifier}"
+      end
+      
+    end # S3
+  end # Storage
+end # CarrierWave