cloudinary 1.0.15 → 1.0.16

data/README.md

@@ -10,7 +10,7 @@ To install the Cloudinary Ruby GEM, run:
 
 	$ gem install cloudinary
 
-I you use Rails 3.x or higher, edit your Gemfile, add the following line and run 'bundle'
+If you use Rails 3.x or higher, edit your Gemfile, add the following line and run 'bundle'
 
 	$ gem 'cloudinary'
 
@@ -18,17 +18,21 @@ Or in Rails 2.x, edit your environment.rb and add:
 
 	$ config.gem 'cloudinary'
 
-If you would like to use our optional integration module of image uploads with ActiveRecord using CarrierWave, install CarrierWave to:
+If you would like to use our optional integration module of image uploads with ActiveRecord using CarrierWave, install CarrierWave GEM:
 
 	$ gem install carrierwave
 
 Rails 3.x Gemfile:
 
 	$ gem 'carrierwave'
+	$ gem 'cloudinary'
 
 Rails 2.x environment.rb
 
 	$ config.gem 'carrierwave', :version => '~> 0.4.1'
+	$ config.gem 'cloudinary'
+
+Note: The CarrierWave GEM should be loaded before the Cloudinary GEM.
 
 
 ## Usage ######################################################################

data/lib/cloudinary/carrier_wave.rb

@@ -1,319 +1,123 @@
 # Copyright Cloudinary
-require 'pp'
-module Cloudinary::CarrierWave
-  CLOUDINARY_PATH = /^([^\/]+)\/upload\/v(\d+)\/([^\/]+)#([^\/]+)$/
-  
-  class UploadError < StandardError
-    attr_reader :http_code
-    def initialize(message, http_code)
-      super(message)
-      @http_code = http_code
-    end
-  end
-  
-  module ClassMethods
-    def eager
-      process :eager => true
-    end
-    
-    def convert(format)
-      process :convert => format
-    end
-
-    def resize_to_limit(width, height)
-      process :resize_to_limit => [width, height]
-    end
-
-    def resize_to_fit(width, height)
-      process :resize_to_fit => [width, height]
-    end
-
-    def resize_to_fill(width, height, gravity="Center")
-      process :resize_to_fill => [width, height, gravity]
-    end
+require 'cloudinary/carrier_wave/process'
+require 'cloudinary/carrier_wave/error'
+require 'cloudinary/carrier_wave/remote'
+require 'cloudinary/carrier_wave/preloaded'
+require 'cloudinary/carrier_wave/storage'
 
-    def resize_and_pad(width, height, background=:transparent, gravity="Center")
-      process :resize_and_pad => [width, height, background, gravity]
-    end    
-
-    def scale(width, height)
-      process :scale => [width, height]
-    end    
-
-    def crop(width, height, gravity="Center")
-      process :crop => [width, height, gravity]
-    end
-
-    def cloudinary_transformation(options)
-      process :cloudinary_transformation => options
-    end
-    
-    def tags(*tags)
-      process :tags=>tags
-    end
-  end
+module Cloudinary::CarrierWave
   
   def self.included(base)
     base.storage Cloudinary::CarrierWave::Storage
     base.extend ClassMethods
     base.send(:attr_accessor, :metadata)
-    base.send(:alias_method, :original_cache!, :cache!)
-    base.send(:alias_method, :original_cache_name, :cache_name)
-    base.send(:alias_method, :original_retrieve_from_cache!, :retrieve_from_cache!)
-    base.send(:include, Override)
-  end
-  
-  module Override
-    def cache!(new_file)
-      if new_file.is_a?(String) && new_file.match(CLOUDINARY_PATH)
-        @file = CloudinaryFile.new(new_file)
-        self.original_filename = @cache_id = @my_filename = @filename = @file.original_filename
-      else
-        original_cache!(new_file)
-      end
-    end
-
-    def retrieve_from_cache!(new_file)
-      if new_file.is_a?(String) && new_file.match(CLOUDINARY_PATH)
-        @file = CloudinaryFile.new(new_file)
-        self.original_filename = @cache_id = @my_filename = @filename = @file.original_filename
-      else
-        original_retrieve_from_cache!(new_file)
-      end
-    end
-    
-    def cache_name
-      if @file.is_a?(CloudinaryFile)
-        return @file.to_s
-      else
-        return original_cache_name
-      end
-    end
-  end
-      
-  def set_or_yell(hash, attr, value)
-    raise "conflicting transformation on #{attr} #{value}!=#{hash[attr]}" if hash[attr]
-    hash[attr] = value
-  end
-  
-  def transformation
-    return @transformation if @transformation
-    transformation = {}
-    self.class.processors.each do
-      |name, args|
-      case name
-      when :convert # Do nothing. This is handled by format
-      when :resize_to_limit 
-        set_or_yell(transformation, :width, args[0])    
-        set_or_yell(transformation, :height, args[1])
-        set_or_yell(transformation, :crop, :limit)
-      when :resize_to_fit 
-        set_or_yell(transformation, :width, args[0])    
-        set_or_yell(transformation, :height, args[1])
-        set_or_yell(transformation, :crop, :fit)
-      when :resize_to_fill
-        set_or_yell(transformation, :width, args[0])    
-        set_or_yell(transformation, :height, args[1])
-        set_or_yell(transformation, :gravity, args[2].to_s.downcase)
-        set_or_yell(transformation, :crop, :fill)
-      when :resize_and_pad
-        set_or_yell(transformation, :width, args[0])    
-        set_or_yell(transformation, :height, args[1])
-        set_or_yell(transformation, :gravity, args[3].to_s.downcase)
-        set_or_yell(transformation, :crop, :pad)
-      when :scale 
-        set_or_yell(transformation, :width, args[0])    
-        set_or_yell(transformation, :height, args[1])
-        set_or_yell(transformation, :crop, :scale)
-      when :crop
-        set_or_yell(transformation, :width, args[0])    
-        set_or_yell(transformation, :height, args[1])
-        set_or_yell(transformation, :gravity, args[2].to_s.downcase)
-        set_or_yell(transformation, :crop, :crop)
-      when :cloudinary_transformation
-        args.each do
-          |attr, value|        
-          set_or_yell(transformation, attr, value)
-        end
-      end
-    end
-    @transformation = transformation
-    @transformation     
-  end
-  
-  def eager
-    @eager ||= self.class.processors.any?{|processor| processor[0] == :eager}
-  end
-
-  def tags
-    @tags ||= self.class.processors.select{|processor| processor[0] == :tags}.map(&:last).first
-  end
+    base.send(:attr_reader, :stored_version)
+        
+    override_in_versions(base, :blank?, :full_public_id)
+  end  
   
-  def format
-    format_processor = self.class.processors.find{|processor| processor[0] == :convert}
-    if format_processor
-      if format_processor[1].is_a?(Array)
-        return format_processor[1][0]
-      end  
-      return format_processor[1]
+  def retrieve_from_store!(identifier)
+    if identifier.blank?
+      @file = @stored_version = @stored_public_id = nil
+      self.original_filename = nil
+    else
+      @file = CloudinaryFile.new(identifier, self)
+      @public_id = @stored_public_id = @file.public_id
+      @stored_version = @file.version
+      self.original_filename = @file.filename
     end
-    the_filename = original_filename || stored_filename
-    return the_filename.split(".").last if the_filename.include?(".")
-    "png" # TODO Default format?
-  end
-  
+  end  
+           
   def url(*args)
     if args.first && !args.first.is_a?(Hash)
       super
     else
-      return nil if self.my_identifier.blank?
+      return super if self.blank?
       options = args.extract_options!
-      options = options.merge(self.class.version_names.blank? ? {} : self.transformation)
-      Cloudinary::Utils.cloudinary_url(self.my_filename, options)
+      options = self.transformation.merge(options) if self.version_name.present?
+      Cloudinary::Utils.cloudinary_url(self.full_public_id, {:format=>self.format}.merge(options))
     end
   end
+      
+  def full_public_id
+    return nil if self.blank?
+    return self.my_public_id if self.stored_version.blank?
+    return "v#{self.stored_version}/#{self.my_public_id}"
+  end    
 
-  def recreate_versions!
-    # Do nothing
-  end
-  
-  def process!(new_file=nil)
-    # Do nothing
-  end
-
-  def stored_filename
-    model.read_uploader(mounted_as)
-  end  
-
-  def my_filename
-    return stored_filename if stored_filename.present?
-    @my_filename ||= "#{self.public_id}.#{self.format}"
+  def filename
+    return nil if self.blank?
+    return [self.full_public_id, self.format].join(".")
   end
-    
+      
+  # public_id to use for uploaded file. Can be overridden by caller. Random public_id will be used otherwise.  
   def public_id
-    return @public_id if @public_id
-    if stored_filename.present?
-      last_dot = stored_filename.rindex(".")
-      @public_id = last_dot ? stored_filename[0, last_dot] : stored_filename 
-    end    
+    nil
+  end
+  
+  # If the user overrode public_id, that should be used, even if it's different from current public_id in the database.
+  # Otherwise, try to use public_id from the database.
+  # Otherwise, generate a new random public_id
+  def my_public_id
+    @public_id ||= self.public_id 
+    @public_id ||= @stored_public_id
     @public_id ||= Cloudinary::Utils.random_public_id
   end  
-  
-  def download!(uri)
-    uri = process_uri(uri)
-    self.original_filename = @cache_id = @filename = File.basename(uri.path).gsub(/[^a-zA-Z0-9\.\-\+_]/, '')
-    @file = RemoteFile.new(uri, @filename)
+
+  def recreate_versions!
+    # Do nothing
   end
   
-  def my_identifier
-    (self.filename || self.stored_filename.present?) ? self.my_filename : nil    
+  def cache_versions!(new_file=nil)
+    # Do nothing
   end
   
-  class RemoveableFile
-    def initialize(identifier)
-      @public_id = identifier.split("/").last.split(".").first
-    end
-    
-    def delete
-      Cloudinary::Uploader.destroy(@public_id)
-    end
+  def process!(new_file=nil)
+    # Do nothing
   end
   
-  class RemoteFile
-    attr_reader :uri, :original_filename
-    def initialize(uri, filename)
-      @uri = uri
-      @original_filename = filename
-    end
-    
-    def delete
-      # Do nothing. This is a virtual file.
-    end
+  # Should removed files be removed from Cloudinary as well. Can be overridden.
+  def delete_remote?
+    true
   end
   
   class CloudinaryFile
-    attr_reader :original_filename, :version
-    def initialize(file_info)
-      resource_type, @version, @original_filename, @signature = file_info.scan(CLOUDINARY_PATH).first
-      raise "Cloudinary CarrierWave integration supports images only" if resource_type != "image"
-      public_id = @original_filename[0..(@original_filename.rindex(".")-1)]
-      expected_signature = Cloudinary::Utils.api_sign_request({:public_id=>public_id, :version=>version}, Cloudinary.config.api_secret)
-      if @signature != expected_signature
-        raise CarrierWave::IntegrityError, I18n.translate(:"errors.messages.cloudinary_signature_error", :public_id=>public_id, :default=>"Invalid signature for #{public_id}")
+    attr_reader :identifier, :public_id, :filename, :format, :version
+    def initialize(identifier, uploader)
+      @uploader = uploader
+      @identifier = identifier
+      if @identifier.include?("/")
+        version, @filename = @identifier.split("/")
+        @version = version[1..-1] # remove 'v' prefix
+      else
+        @filename = @identifier
+        @version = nil 
       end
+      @public_id, @format = Cloudinary::CarrierWave.split_format(@filename)      
     end
     
-    def to_s
-      "image/upload/v#{@version}/#{@original_filename}##{@signature}"
-    end
-
     def delete
-      # Do nothing. This is a virtual file.
+      Cloudinary::Uploader.destroy(self.public_id) if @uploader.delete_remote?        
     end
   end
-  
-  class Storage < ::CarrierWave::Storage::Abstract
-    def store!(file)
-      # Moved to identifier...
-      if uploader.class.version_names.blank?
-        return store_cloudinary_version(file.version) if file.is_a?(CloudinaryFile)
-        
-        # This is the toplevel, need to upload the actual file.     
-        params = uploader.transformation.dup
-        params[:return_error] = true
-        params[:format] = uploader.format
-        params[:public_id] = uploader.public_id.split("/").last
-        params[:tags] = uploader.tags if uploader.tags 
-        eager_versions = uploader.versions.values.select(&:eager)
-        params[:eager] = eager_versions.map{|version| [version.transformation, version.format]} if eager_versions.length > 0
-        
-        data = nil
-        if (file.is_a?(RemoteFile))
-          data = file.uri.to_s
-        else
-          data = file.file
-          data.rewind if !file.is_path? && data.respond_to?(:rewind)
-        end
-        uploader.metadata = Cloudinary::Uploader.upload(data, params)
-        if uploader.metadata["error"]
-          raise UploadError.new(uploader.metadata["error"]["message"], uploader.metadata["error"]["http_code"])
-        end
-        
-        store_cloudinary_version(uploader.metadata["version"]) if uploader.metadata["version"]
-        # Will throw an exception on error
-      else
-        raise "nested versions are not allowed." if (uploader.class.version_names.length > 1)
-        # Do nothing
-      end
-      nil
-    end
-    
-    def store_cloudinary_version(version)
-      name = "v#{version}/#{identifier.split("/").last}"
-      model_class = uploader.model.class
-      if defined?(ActiveRecord::Base) && uploader.model.is_a?(ActiveRecord::Base)
-        primary_key = model_class.primary_key.to_sym
-        model_class.update_all({uploader.mounted_as=>name}, {primary_key=>uploader.model.send(primary_key)})
-        uploader.model.send :write_attribute, uploader.mounted_as, name
-      elsif model_class.respond_to?(:update_all) && uploader.model.respond_to?(:_id)
-        # Mongoid support
-        model_class.where(:_id=>uploader.model._id).update_all(uploader.mounted_as=>name)
-        uploader.model.send :write_attribute, uploader.mounted_as, name
-      else
-        raise "Only ActiveRecord and Mongoid are supported at the moment!"
+
+  def self.split_format(identifier)
+    last_dot = identifier.rindex(".")
+    return [public_id, nil] if last_dot.nil?
+    public_id = identifier[0, last_dot]
+    format = identifier[last_dot+1..-1]
+    return [public_id, format]    
+  end
+
+  # For the given methods - versions should call the main uploader method
+  def self.override_in_versions(base, *methods)
+    methods.each do
+      |method|
+      base.send :define_method, method do
+        return super() if self.version_name.blank?
+        uploader = self.model.send(self.mounted_as)
+        uploader.send(method)    
       end
-    end
-    
-    def retrieve!(identifier)
-      if uploader.class.version_names.blank?
-        return RemoveableFile.new(identifier)
-      else
-        return nil # Version files should not be deleted.
-      end      
-    end 
-    
-    def identifier
-      uploader.my_identifier      
-    end   
+    end    
   end
 end

data/lib/cloudinary/carrier_wave/error.rb

@@ -0,0 +1,9 @@
+module Cloudinary::CarrierWave
+  class UploadError < StandardError
+    attr_reader :http_code
+    def initialize(message, http_code)
+      super(message)
+      @http_code = http_code
+    end
+  end
+end

data/lib/cloudinary/carrier_wave/preloaded.rb

@@ -0,0 +1,62 @@
+# Copyright Cloudinary
+# Support for store in CarrierWave files that were preloaded to cloudinary (e.g., by javascript)
+# Field value must be in the format:  "image/upload/v<version>/#<public_id>.<format>#<signature>"
+# Where signature is the cloduinary API signature on the public_id and version.
+module Cloudinary::CarrierWave
+  PRELOADED_CLOUDINARY_PATH = /^([^\/]+)\/upload\/v(\d+)\/([^\/]+)#([^\/]+)$/
+
+  def cache!(new_file)
+    if new_file.is_a?(String) && new_file.match(PRELOADED_CLOUDINARY_PATH)
+      @file = PreloadedCloudinaryFile.new(new_file)
+      @stored_version = @file.version
+      @public_id = @stored_public_id = @file.public_id
+      self.original_filename = @file.original_filename
+      @cache_id = "unused" # must not be blank 
+    else
+      super
+      @public_id = nil # allow overriding public_id
+    end
+  end
+
+  def retrieve_from_cache!(new_file)
+    if new_file.is_a?(String) && new_file.match(PRELOADED_CLOUDINARY_PATH)
+      @file = PreloadedCloudinaryFile.new(new_file)
+      @stored_version = @file.version
+      @public_id = @stored_public_id = @file.public_id
+      self.original_filename = @file.original_filename
+      @cache_id = "unused" # must not be blank 
+    else
+      super
+      @public_id = nil # allow overriding public_id
+    end
+  end
+  
+  def cache_name
+    return @file.is_a?(PreloadedCloudinaryFile) ? @file.to_s : super
+  end
+  
+  class PreloadedCloudinaryFile
+    attr_reader :original_filename, :version, :public_id, :signature
+    def initialize(file_info)
+      resource_type, @version, @original_filename, @signature = file_info.scan(PRELOADED_CLOUDINARY_PATH).first
+      raise "Cloudinary CarrierWave integration supports images only" if resource_type != "image"
+      @public_id = @original_filename[0..(@original_filename.rindex(".")-1)]
+      expected_signature = Cloudinary::Utils.api_sign_request({:public_id=>public_id, :version=>version}, Cloudinary.config.api_secret)
+      if @signature != expected_signature
+        raise CarrierWave::IntegrityError, I18n.translate(:"errors.messages.cloudinary_signature_error", :public_id=>public_id, :default=>"Invalid signature for #{public_id}")
+      end      
+    end
+    
+    def identifier
+      "v#{version}/#{original_filename}"
+    end
+    
+    def to_s
+      "image/upload/v#{version}/#{original_filename}##{signature}"
+    end
+
+    def delete
+      # Do nothing. This is a virtual file.
+    end
+  end  
+end

data/lib/cloudinary/carrier_wave/process.rb

@@ -0,0 +1,117 @@
+module Cloudinary::CarrierWave
+  module ClassMethods
+    def eager
+      process :eager => true
+    end
+    
+    def convert(format)
+      process :convert => format
+    end
+  
+    def resize_to_limit(width, height)
+      process :resize_to_limit => [width, height]
+    end
+  
+    def resize_to_fit(width, height)
+      process :resize_to_fit => [width, height]
+    end
+  
+    def resize_to_fill(width, height, gravity="Center")
+      process :resize_to_fill => [width, height, gravity]
+    end
+  
+    def resize_and_pad(width, height, background=:transparent, gravity="Center")
+      process :resize_and_pad => [width, height, background, gravity]
+    end    
+  
+    def scale(width, height)
+      process :scale => [width, height]
+    end    
+  
+    def crop(width, height, gravity="Center")
+      process :crop => [width, height, gravity]
+    end
+  
+    def cloudinary_transformation(options)
+      process :cloudinary_transformation => options
+    end
+    
+    def tags(*tags)
+      process :tags=>tags
+    end
+  end
+
+  def set_or_yell(hash, attr, value)
+    raise "conflicting transformation on #{attr} #{value}!=#{hash[attr]}" if hash[attr]
+    hash[attr] = value
+  end
+  
+  def transformation
+    return @transformation if @transformation
+    @transformation = {}
+    self.class.processors.each do
+      |name, args|
+      case name
+      when :convert # Do nothing. This is handled by format
+      when :resize_to_limit 
+        set_or_yell(@transformation, :width, args[0])    
+        set_or_yell(@transformation, :height, args[1])
+        set_or_yell(@transformation, :crop, :limit)
+      when :resize_to_fit 
+        set_or_yell(@transformation, :width, args[0])    
+        set_or_yell(@transformation, :height, args[1])
+        set_or_yell(@transformation, :crop, :fit)
+      when :resize_to_fill
+        set_or_yell(@transformation, :width, args[0])    
+        set_or_yell(@transformation, :height, args[1])
+        set_or_yell(@transformation, :gravity, args[2].to_s.downcase)
+        set_or_yell(@transformation, :crop, :fill)
+      when :resize_and_pad
+        set_or_yell(@transformation, :width, args[0])    
+        set_or_yell(@transformation, :height, args[1])
+        set_or_yell(@transformation, :background, args[2].to_s.downcase)
+        set_or_yell(@transformation, :gravity, args[3].to_s.downcase)
+        set_or_yell(@transformation, :crop, :pad)
+      when :scale 
+        set_or_yell(@transformation, :width, args[0])    
+        set_or_yell(@transformation, :height, args[1])
+        set_or_yell(@transformation, :crop, :scale)
+      when :crop
+        set_or_yell(@transformation, :width, args[0])    
+        set_or_yell(@transformation, :height, args[1])
+        set_or_yell(@transformation, :gravity, args[2].to_s.downcase)
+        set_or_yell(@transformation, :crop, :crop)
+      when :cloudinary_transformation
+        args.each do
+          |attr, value|        
+          set_or_yell(@transformation, attr, value)
+        end
+      end
+    end
+    @transformation     
+  end
+
+  def eager
+    @eager ||= self.class.processors.any?{|processor| processor[0] == :eager}
+  end
+
+  def tags
+    @tags ||= self.class.processors.select{|processor| processor[0] == :tags}.map(&:last).first
+  end
+  
+  def format
+    format_processor = self.class.processors.find{|processor| processor[0] == :convert}
+    if format_processor 
+      # Explicit format is given
+      return Array(format_processor[1]).first 
+    elsif self.version_name.present? 
+      # No local format. The reset should be handled by main uploader
+      uploader = self.model.send(self.mounted_as)
+      return uploader.format
+    else
+      # Try to auto-detect format
+      format = Cloudinary::CarrierWave.split_format(original_filename || "").last
+      return format || "png" # TODO Default format? 
+    end
+  end
+end

data/lib/cloudinary/carrier_wave/remote.rb

@@ -0,0 +1,23 @@
+module Cloudinary::CarrierWave
+  def download!(uri)
+    if respond_to?(:process_uri)
+      uri = process_uri(uri)
+    else # Backward compatibility with old CarrierWave
+      uri = URI.parse(URI.escape(URI.unescape(uri)))
+    end
+    self.original_filename = @cache_id = @filename = File.basename(uri.path).gsub(/[^a-zA-Z0-9\.\-\+_]/, '')
+    @file = RemoteFile.new(uri, @filename)
+  end
+
+  class RemoteFile
+    attr_reader :uri, :original_filename
+    def initialize(uri, filename)
+      @uri = uri
+      @original_filename = filename
+    end
+    
+    def delete
+      # Do nothing. This is a virtual file.
+    end
+  end
+end  

data/lib/cloudinary/carrier_wave/storage.rb

@@ -0,0 +1,51 @@
+class Cloudinary::CarrierWave::Storage < ::CarrierWave::Storage::Abstract
+  def store!(file)
+    if uploader.class.version_names.blank?
+      return store_cloudinary_version(file.version) if file.is_a?(Cloudinary::CarrierWave::PreloadedCloudinaryFile)
+      
+      # This is the toplevel, need to upload the actual file.     
+      params = uploader.transformation.dup
+      params[:return_error] = true
+      params[:format] = uploader.format
+      params[:public_id] = uploader.my_public_id
+      params[:tags] = uploader.tags if uploader.tags 
+      eager_versions = uploader.versions.values.select(&:eager)
+      params[:eager] = eager_versions.map{|version| [version.transformation, version.format]} if eager_versions.length > 0
+      
+      data = nil
+      if (file.is_a?(Cloudinary::CarrierWave::RemoteFile))
+        data = file.uri.to_s
+      else
+        data = file.file
+        data.rewind if !file.is_path? && data.respond_to?(:rewind)
+      end
+      uploader.metadata = Cloudinary::Uploader.upload(data, params)
+      if uploader.metadata["error"]
+        raise Cloudinary::CarrierWave::UploadError.new(uploader.metadata["error"]["message"], uploader.metadata["error"]["http_code"])
+      end
+      
+      store_cloudinary_version(uploader.metadata["version"]) if uploader.metadata["version"]
+      # Will throw an exception on error
+    else
+      raise "nested versions are not allowed." if (uploader.class.version_names.length > 1)
+      # Do nothing - versions are not handled locally.
+    end
+    nil
+  end
+  
+  def store_cloudinary_version(version)
+    name = "v#{version}/#{identifier.split("/").last}"
+    model_class = uploader.model.class
+    if defined?(ActiveRecord::Base) && uploader.model.is_a?(ActiveRecord::Base)
+      primary_key = model_class.primary_key.to_sym
+      model_class.update_all({uploader.mounted_as=>name}, {primary_key=>uploader.model.send(primary_key)})
+      uploader.model.send :write_attribute, uploader.mounted_as, name
+    elsif model_class.respond_to?(:update_all) && uploader.model.respond_to?(:_id)
+      # Mongoid support
+      model_class.where(:_id=>uploader.model._id).update_all(uploader.mounted_as=>name)
+      uploader.model.send :write_attribute, uploader.mounted_as, name
+    else
+      raise "Only ActiveRecord and Mongoid are supported at the moment!"
+    end
+  end  
+end

data/lib/cloudinary/helper.rb

@@ -20,7 +20,7 @@ module CloudinaryHelper
   def cl_image_path(source, options = {})
     options = options.clone
     url = cloudinary_url(source, options)
-    original_image_path(url, options)    
+    original_image_path(url)    
   end
     
   def image_tag(*args)
@@ -188,6 +188,7 @@ rescue LoadError
 end
 
 begin
+  require 'sass'
   require 'sass/script/functions'
   module Sass::Script::Functions
     def cloudinary_url(public_id, sass_options={})

data/lib/cloudinary/utils.rb

@@ -21,6 +21,8 @@ class Cloudinary::Utils
     y = options.delete(:y)
     radius = options.delete(:radius)
     default_image = options.delete(:default_image)
+    background = options.delete(:background)
+    background = background.sub(/^#/, 'rgb:') if background
     
     gravity = options.delete(:gravity)
     quality = options.delete(:quality)
@@ -36,7 +38,7 @@ class Cloudinary::Utils
     end
     prefix = options.delete(:prefix)
 
-    params = {:w=>width, :h=>height, :t=>named_transformation, :c=>crop, :q=>quality, :g=>gravity, :p=>prefix, :x=>x, :y=>y, :r=>radius, :d=>default_image}
+    params = {:w=>width, :h=>height, :t=>named_transformation, :c=>crop, :q=>quality, :g=>gravity, :p=>prefix, :x=>x, :y=>y, :r=>radius, :d=>default_image, :b=>background}
     transformation = params.reject{|k,v| v.blank?}.map{|k,v| [k.to_s, v]}.sort_by(&:first).map{|k,v| "#{k}_#{v}"}.join(",")
     raw_transformation = options.delete(:raw_transformation)
     transformation = [transformation, raw_transformation].reject(&:blank?).join(",")
@@ -64,6 +66,7 @@ class Cloudinary::Utils
     secure_distribution = options.delete(:secure_distribution) || Cloudinary.config.secure_distribution
     force_remote = options.delete(:force_remote)  
     
+    return original_source if source.blank?
     if !force_remote    
       return original_source if (type.nil? || type == :asset) && source.match(%r(^https?:/)i)
       if source.start_with?("/") 
@@ -138,6 +141,10 @@ class Cloudinary::Utils
   def self.random_public_id
     (defined?(ActiveSupport::SecureRandom) ? ActiveSupport::SecureRandom : SecureRandom).base64(16).downcase.gsub(/[^a-z0-9]/, "")    
   end
+
+  def self.signed_preloaded_image(result)
+    "#{result["resource_type"]}/upload/v#{result["version"]}/#{[result["public_id"], result["format"]].join(".")}##{result["signature"]}"
+  end
   
   @@json_decode = false
   def self.json_decode(str)

data/lib/cloudinary/version.rb

@@ -1,4 +1,4 @@
 # Copyright Cloudinary
 module Cloudinary
-  VERSION = "1.0.15"
+  VERSION = "1.0.16"
 end

metadata

@@ -2,7 +2,7 @@
 name: cloudinary
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.0.15
+  version: 1.0.16
 platform: ruby
 authors: 
 - Nadav Soferman
@@ -12,7 +12,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-23 00:00:00 +03:00
+date: 2012-04-25 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -58,6 +58,11 @@ files:
 - lib/cloudinary.rb
 - lib/cloudinary/blob.rb
 - lib/cloudinary/carrier_wave.rb
+- lib/cloudinary/carrier_wave/error.rb
+- lib/cloudinary/carrier_wave/preloaded.rb
+- lib/cloudinary/carrier_wave/process.rb
+- lib/cloudinary/carrier_wave/remote.rb
+- lib/cloudinary/carrier_wave/storage.rb
 - lib/cloudinary/controller.rb
 - lib/cloudinary/downloader.rb
 - lib/cloudinary/helper.rb