cloudinary 1.0.85 → 1.1.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZTNjODQ0YjA3MzJjMjNhMmEwNzIyZGExNTRiY2JhMGZjZGYyNTI0MQ==
-  data.tar.gz: !binary |-
-    MjhkM2NkNzk1YTExOWQ0ZjdjMTJlNWIzOTE2YzZhMjE2NWZhNDM5OQ==
+SHA1:
+  metadata.gz: ed522de3b73b3847f23d46ee3ec165e7cdf20037
+  data.tar.gz: 2bda2d2079cf979dd6622e23ec4187dbcf56be34
 SHA512:
-  metadata.gz: !binary |-
-    YWM4OGJmYmQxNjc3OGIwYWQ5Y2U4OThhNGJkMDYxNTBlOWNlYzBjZDliYTBm
-    OWIyZmY1MDI4NzlhODIzZmFmNWJkZDQyYTAyOWZmNzc0MzFjMWRlZDUyZGY5
-    ZmYwYjQ5ODFiODM0Y2VlNjViN2JjOTJmODI2ODBiNzk4NWViMjk=
-  data.tar.gz: !binary |-
-    NTE4NDkyMGU0ZDk3MDNiNjA0OWMwZDZjNTU1OThjNjI3OTQ3Zjg1ZTkxM2U2
-    MGFjODMxOTBiNDgyYmMyYTdmZmM1Y2FkMWM0ZGZmOWI2MjM3NjUzY2E4ZDhk
-    YTc5OGY1OWIzNTIzYjcwYzRmNmMzZThiZjcwMTI4MTQyOTU3NmY=
+  metadata.gz: d75f033f6b0a02263f626b9f2f2c57de96fcf773eb455079fb647bf50c447f8280138eeb93298ba67a4d22f34c42f1f5ca29af1eb108dbe303fc19efd93b90ac
+  data.tar.gz: c815b8e4af15df396cc425ab505608c577c7f2616d76101041bf9c41f1561aea69fd7676a14294ef7df418d86c2375e044db6c7e6630b4d95b48c5f300e8fa30

data/.gitignore

@@ -3,9 +3,9 @@
 /.config
 capybara-*.html
 .rspec
-log/
-db/*.sqlite3
-db/*.sqlite3-journal
+/log
+/db/*.sqlite3
+/db/*.sqlite3-journal
 /public/system
 /coverage/
 /InstalledFiles
@@ -14,7 +14,7 @@ db/*.sqlite3-journal
 /test/tmp/
 /spec/tmp
 /test/version_tmp/
-tmp/
+/tmp
 **.orig
 rerun.txt
 pickle-email-*.html
@@ -49,7 +49,7 @@ Gemfile.lock
 .rvmrc
 
 # if using bower-rails ignore default bower_components path bower.json files
-vendor/assets/bower_components
+/vendor/assets/bower_components
 *.bowerrc
 bower.json
 

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+# Version 1.1.0 - 2015-04-21
+  * Pull request #136 - Update `process.rb` to ensure name value is an array.
+  * CarrierWave
+    * Store `resource_type` and `type` (aka `storage_type`) in carrierwave column for better support of non-image resource types and non-upload types
+    * only pass format to Cloudinary when explicitly requested
+    * Support disabling new extended identifier format
+  * Use upload endpoint instead of upload_chunked
+  * Remove `symoblize_keys` monkey patching
+  * Update Rspec dependency.
+  * Fix markup in the readme file.
+  * Add `.gitignore` to each sample project. Add files required for testing.
+  * Fix changelog format (missing newline)
+
 # Version 1.0.85 - 2015-04-08
   * Remove symoblize_keys intrusive implementation.  
   * Use upload API endpoint instead of upload_chunked.

data/README.md

@@ -12,13 +12,13 @@ Cloudinary provides URL and HTTP based APIs that can be easily integrated with a
 For Ruby on Rails, Cloudinary provides a GEM for simplifying the integration even further.
 
 ## Getting started guide
-![](http://res.cloudinary.com/cloudinary/image/upload/see_more_bullet.png)  **Take a look at our [Getting started guide of Ruby on Rails](http://cloudinary.com/documentation/rails_integration#getting_started_guide)**.
+![More](http://res.cloudinary.com/cloudinary/image/upload/see_more_bullet.png)  **Take a look at our [Getting started guide of Ruby on Rails](http://cloudinary.com/documentation/rails_integration#getting_started_guide)**.
 
 ## Setup ######################################################################
 
 To install the Cloudinary Ruby GEM, run:
 
-	$ gem install cloudinary
+    $ gem install cloudinary
 
 If you use Rails 3.x or higher, edit your `Gemfile`, add the following line and run `bundle install`
 
@@ -117,7 +117,7 @@ Same goes for Twitter:
 
     twitter_name_profile_image_tag("billclinton.jpg")
 
-![](http://res.cloudinary.com/cloudinary/image/upload/see_more_bullet.png) **See [our documentation](http://cloudinary.com/documentation/rails_image_manipulation) for more information about displaying and transforming images in Rails**.                                         
+![More](http://res.cloudinary.com/cloudinary/image/upload/see_more_bullet.png) **See [our documentation](http://cloudinary.com/documentation/rails_image_manipulation) for more information about displaying and transforming images in Rails**.                                         
 
 
 
@@ -144,11 +144,14 @@ You can also specify your own public ID:
     http://res.cloudinary.com/demo/image/upload/sample_remote.jpg
 
 
-![](http://res.cloudinary.com/cloudinary/image/upload/see_more_bullet.png) **See [our documentation](http://cloudinary.com/documentation/rails_image_upload) for plenty more options of uploading to the cloud from your Ruby code or directly from the browser**.
+![More](http://res.cloudinary.com/cloudinary/image/upload/see_more_bullet.png) **See [our documentation](http://cloudinary.com/documentation/rails_image_upload) for plenty more options of uploading to the cloud from your Ruby code or directly from the browser**.
 
 
 ### CarrierWave Integration
 
+**Note:** Starting from version 1.1.0 the CarrierWave database format has changed to include the resource type and storage type. The new functionality
+is backward compatible with the previous format. To use the old format override `use_extended_identifier?` in the Uploader and return `false`.
+
 Cloudinary's Ruby GEM includes an optional plugin for [CarrierWave](https://github.com/jnicklas/carrierwave). If you already use CarrierWave, simply include `Cloudinary::CarrierWave` to switch to cloud storage and image processing in the cloud. 
 
     class PictureUploader < CarrierWave::Uploader::Base    
@@ -156,7 +159,7 @@ Cloudinary's Ruby GEM includes an optional plugin for [CarrierWave](https://gith
         ...  
     end
 
-![](http://res.cloudinary.com/cloudinary/image/upload/see_more_bullet.png) **For more details on CarrierWave integration see [our documentation](http://cloudinary.com/documentation/rails_carrierwave)**.
+![More](http://res.cloudinary.com/cloudinary/image/upload/see_more_bullet.png) **For more details on CarrierWave integration see [our documentation](http://cloudinary.com/documentation/rails_carrierwave)**.
 
 We also published an interesting blog post about [Ruby on Rails image uploads with CarrierWave and Cloudinary](http://cloudinary.com/blog/ruby_on_rails_image_uploads_with_carrierwave_and_cloudinary).
 

data/Rakefile

@@ -7,7 +7,7 @@ task :default => :spec
 Bundler::GemHelper.install_tasks
 
 task :fetch_assets do
-  system "/bin/rm -rf vendor/assets; mkdir -p vendor/assets; cd vendor/assets; curl -L https://github.com/cloudinary/cloudinary_js/archive/1.0.23.tar.gz | tar zxvf - --strip=1"
+  system "/bin/rm -rf vendor/assets; mkdir -p vendor/assets; cd vendor/assets; curl -L https://github.com/cloudinary/cloudinary_js/tarball/master | tar zxvf - --strip=1"
   system "mkdir -p vendor/assets/javascripts; mv vendor/assets/js vendor/assets/javascripts/cloudinary"
   File.open("vendor/assets/javascripts/cloudinary/index.js", "w") do 
     |f|

data/cloudinary.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.add_dependency "aws_cf_signer"
-  s.add_development_dependency "rspec", '>=2.11'
+  s.add_development_dependency "rspec", '>=3.2'
   s.add_development_dependency "rspec-rails"
 
   if RUBY_VERSION > "1.9"

data/lib/cloudinary/carrier_wave.rb

@@ -135,6 +135,11 @@ module Cloudinary::CarrierWave
   def auto_rename_preloaded?
     true
   end
+
+  # Use extended identifier format that includes resource type and storage type.
+  def use_extended_identifier?
+    true
+  end
   
   class CloudinaryFile
     attr_reader :identifier, :public_id, :filename, :format, :version, :storage_type, :resource_type
@@ -142,7 +147,12 @@ module Cloudinary::CarrierWave
       @uploader = uploader
       @identifier = identifier
 
-      if @identifier.match(%r(^v([0-9]+)/(.*)))
+      if @identifier.match(%r(^(image|raw|video)/(upload|private|authenticated)(?:/v([0-9]+))?/(.*)))
+        @resource_type = $1
+        @storage_type = $2
+        @version = $3.presence
+        @filename = $4
+      elsif @identifier.match(%r(^v([0-9]+)/(.*)))
         @version = $1
         @filename = $2
       else
@@ -150,8 +160,8 @@ module Cloudinary::CarrierWave
         @version = nil 
       end
 
-      @storage_type = uploader.class.storage_type
-      @resource_type = Cloudinary::Utils.resource_type_for_format(@filename)      
+      @storage_type ||= uploader.class.storage_type
+      @resource_type ||= Cloudinary::Utils.resource_type_for_format(@filename)      
       @public_id, @format = Cloudinary::PreloadedFile.split_format(@filename)      
     end
     
@@ -180,8 +190,12 @@ module Cloudinary::CarrierWave
     "png"
   end
 
+  def storage_type
+    @file.respond_to?(:storage_type) ? @file.storage_type : self.class.storage_type
+  end
+
   def resource_type
-    Cloudinary::Utils.resource_type_for_format(requested_format || original_filename || default_format)
+    @file.respond_to?(:resource_type) ? @file.resource_type : Cloudinary::Utils.resource_type_for_format(requested_format || original_filename || default_format)
   end
   
   # For the given methods - versions should call the main uploader method

data/lib/cloudinary/carrier_wave/process.rb

@@ -105,7 +105,7 @@ module Cloudinary::CarrierWave
         end
       else
         if args.blank?
-          send(name).each do
+          Array(send(name)).each do
             |attr, value|
             set_or_yell(@transformation, attr, value)
           end

data/lib/cloudinary/carrier_wave/storage.rb

@@ -11,11 +11,11 @@ class Cloudinary::CarrierWave::Storage < ::CarrierWave::Storage::Abstract
           @stored_version = file.version
           uploader.rename(nil, true)
         else
-          store_cloudinary_identifier(file.version, file.filename)
+          store_cloudinary_identifier(file.version, file.filename, file.resource_type, file.type)
         end
-        return
+        return # Nothing to do
       when Cloudinary::CarrierWave::CloudinaryFile, Cloudinary::CarrierWave::StoredFile
-        return nil # Nothing to do
+        return # Nothing to do
       when Cloudinary::CarrierWave::RemoteFile
         data = file.uri.to_s
       else
@@ -26,7 +26,7 @@ class Cloudinary::CarrierWave::Storage < ::CarrierWave::Storage::Abstract
       # This is the toplevel, need to upload the actual file.
       params = uploader.transformation.dup
       params[:return_error] = true
-      params[:format] = uploader.format
+      params[:format] = uploader.requested_format
       params[:public_id] = uploader.my_public_id
       uploader.versions.values.each(&:tags) # Validate no tags in versions
       params[:tags] = uploader.tags if uploader.tags
@@ -42,7 +42,7 @@ class Cloudinary::CarrierWave::Storage < ::CarrierWave::Storage::Abstract
 
       if uploader.metadata["version"]
         filename = [uploader.metadata["public_id"], uploader.metadata["format"]].reject(&:blank?).join(".")
-        store_cloudinary_identifier(uploader.metadata["version"], filename)
+        store_cloudinary_identifier(uploader.metadata["version"], filename, uploader.metadata["resource_type"], uploader.metadata["type"])
       end
       # Will throw an exception on error
     else
@@ -52,24 +52,18 @@ class Cloudinary::CarrierWave::Storage < ::CarrierWave::Storage::Abstract
     nil
   end
 
-  # @deprecated For backward compatibility
-  def store_cloudinary_version(version)
-    if identifier.match(%r(^(v[0-9]+)/(.*)))
-      filename = $2
-    else
-      filename = identifier
-    end
-
-    store_cloudinary_identifier(version, filename)
-  end
-
   # Updates the model mounter identifier with version information.
   #
   # Carrierwave uses hooks when integrating with ORMs so it's important to
   # update the identifier in a way that does not trigger hooks again or else
   # you'll get stuck in a loop.
-  def store_cloudinary_identifier(version, filename)
+  def store_cloudinary_identifier(version, filename, resource_type=nil, type=nil)
     name = "v#{version}/#{filename}"
+    if uploader.use_extended_identifier?
+      resource_type ||= uploader.resource_type || "image"
+      type ||= uploader.storage_type || "upload"
+      name = "#{resource_type}/#{type}/#{name}"
+    end
     model_class = uploader.model.class
     column = uploader.model.send(:_mounter, uploader.mounted_as).send(:serialization_column)
     if defined?(ActiveRecord::Base) && uploader.model.is_a?(ActiveRecord::Base)

data/lib/cloudinary/utils.rb

@@ -1,551 +1,554 @@
-# Copyright Cloudinary
-require 'digest/sha1'
-require 'zlib'
-require 'uri'
-require 'aws_cf_signer'
-
-class Cloudinary::Utils
-  # @deprecated Use Cloudinary::SHARED_CDN
-  SHARED_CDN = Cloudinary::SHARED_CDN
-  DEFAULT_RESPONSIVE_WIDTH_TRANSFORMATION = {:width => :auto, :crop => :limit}
-
-  # Warning: options are being destructively updated!
-  def self.generate_transformation_string(options={})
-    if options.is_a?(Array)
-      return options.map{|base_transformation| generate_transformation_string(base_transformation.clone)}.join("/")
-    end
-    # Symbolize keys
-    options.keys.each do |key|
-      options[(key.to_sym rescue key)] = options.delete(key)
-    end
-    
-    responsive_width = config_option_consume(options, :responsive_width) 
-    size = options.delete(:size)
-    options[:width], options[:height] = size.split("x") if size
-    width = options[:width]
-    width = width.to_s if width.is_a?(Symbol)
-    height = options[:height]
-    has_layer = options[:overlay].present? || options[:underlay].present?
-
-    crop = options.delete(:crop)
-    angle = build_array(options.delete(:angle)).join(".")
-
-    no_html_sizes = has_layer || angle.present? || crop.to_s == "fit" || crop.to_s == "limit" || crop.to_s == "lfill"
-    options.delete(:width) if width && (width.to_f < 1 || no_html_sizes || width == "auto" || responsive_width)
-    options.delete(:height) if height && (height.to_f < 1 || no_html_sizes || responsive_width)
-
-    width=height=nil if crop.nil? && !has_layer && width != "auto"
-
-    background = options.delete(:background)
-    background = background.sub(/^#/, 'rgb:') if background
-
-    color = options.delete(:color)
-    color = color.sub(/^#/, 'rgb:') if color
-
-    base_transformations = build_array(options.delete(:transformation))
-    if base_transformations.any?{|base_transformation| base_transformation.is_a?(Hash)}
-      base_transformations = base_transformations.map do
-        |base_transformation|
-        base_transformation.is_a?(Hash) ? generate_transformation_string(base_transformation.clone) : generate_transformation_string(:transformation=>base_transformation)
-      end
-    else
-      named_transformation = base_transformations.join(".")
-      base_transformations = []
-    end
-
-    effect = options.delete(:effect)
-    effect = Array(effect).flatten.join(":") if effect.is_a?(Array) || effect.is_a?(Hash)
-
-    border = options.delete(:border)
-    if border.is_a?(Hash)
-      border = "#{border[:width] || 2}px_solid_#{(border[:color] || "black").sub(/^#/, 'rgb:')}"
-    elsif border.to_s =~ /^\d+$/ # fallback to html border attribute
-      options[:border] = border
-      border = nil
-    end
-    flags = build_array(options.delete(:flags)).join(".")
-    dpr = config_option_consume(options, :dpr)
-
-    if options.include? :offset
-      options[:start_offset], options[:end_offset] = split_range options.delete(:offset)
-    end
-
-    params = {
-      :a   => angle,
-      :b   => background,
-      :bo  => border,
-      :c   => crop,
-      :co  => color,
-      :dpr => dpr,
-      :e   => effect,
-      :fl  => flags,
-      :h   => height,
-      :t   => named_transformation,
-      :w   => width
-    }
-    {
-      :ac => :audio_codec,
-      :br => :bit_rate,
-      :cs => :color_space,
-      :d  => :default_image,
-      :dl => :delay,
-      :dn => :density,
-      :du => :duration,
-      :eo => :end_offset,
-      :f  => :fetch_format,
-      :g  => :gravity,
-      :l  => :overlay,
-      :o  => :opacity,
-      :p  => :prefix,
-      :pg => :page,
-      :q  => :quality,
-      :r  => :radius,
-      :af => :audio_frequency,
-      :so => :start_offset,
-      :u  => :underlay,
-      :vc => :video_codec,
-      :vs => :video_sampling,
-      :x  => :x,
-      :y  => :y,
-      :z  => :zoom
-    }.each do
-      |param, option|
-      params[param] = options.delete(option)
-    end
-
-    params[:vc] = process_video_params params[:vc] if params[:vc].present?
-    [:so, :eo, :du].each do |range_value|
-      params[range_value] = norm_range_value params[range_value] if params[range_value].present?
-    end
-
-    transformation = params.reject{|_k,v| v.blank?}.map{|k,v| "#{k}_#{v}"}.sort.join(",")
-    raw_transformation = options.delete(:raw_transformation)
-    transformation = [transformation, raw_transformation].reject(&:blank?).join(",")
-    transformations = base_transformations << transformation
-    if responsive_width
-      responsive_width_transformation = Cloudinary.config.responsive_width_transformation || DEFAULT_RESPONSIVE_WIDTH_TRANSFORMATION
-      transformations << generate_transformation_string(responsive_width_transformation.clone)
-    end
-
-    if width.to_s == "auto" || responsive_width
-      options[:responsive] = true
-    end
-    if dpr.to_s == "auto"
-      options[:hidpi] = true
-    end
-
-    transformations.reject(&:blank?).join("/")
-  end
-
-  def self.api_string_to_sign(params_to_sign)
-    params_to_sign.map{|k,v| [k.to_s, v.is_a?(Array) ? v.join(",") : v]}.reject{|k,v| v.nil? || v == ""}.sort_by(&:first).map{|k,v| "#{k}=#{v}"}.join("&")
-  end
-
-  def self.api_sign_request(params_to_sign, api_secret)
-    to_sign = api_string_to_sign(params_to_sign)
-    Digest::SHA1.hexdigest("#{to_sign}#{api_secret}")
-  end
-
-  # Warning: options are being destructively updated!
-  def self.unsigned_download_url(source, options = {})
-
-    type = options.delete(:type)
-
-    options[:fetch_format] ||= options.delete(:format) if type == :fetch
-    transformation = self.generate_transformation_string(options)
-
-    resource_type = options.delete(:resource_type) || "image"
-    version = options.delete(:version)
-    format = options.delete(:format)
-    cloud_name = config_option_consume(options, :cloud_name) || raise(CloudinaryException, "Must supply cloud_name in tag or in configuration")
-
-    secure = options.delete(:secure)
-    ssl_detected = options.delete(:ssl_detected)
-    secure = ssl_detected || Cloudinary.config.secure if secure.nil?
-    private_cdn = config_option_consume(options, :private_cdn)
-    secure_distribution = config_option_consume(options, :secure_distribution)
-    cname = config_option_consume(options, :cname)
-    shorten = config_option_consume(options, :shorten)
-    force_remote = options.delete(:force_remote)
-    cdn_subdomain = config_option_consume(options, :cdn_subdomain)
-    secure_cdn_subdomain = config_option_consume(options, :secure_cdn_subdomain)
-    sign_url = config_option_consume(options, :sign_url)
-    secret = config_option_consume(options, :api_secret)
-    sign_version = config_option_consume(options, :sign_version) # Deprecated behavior
-    url_suffix = options.delete(:url_suffix)
-    use_root_path = config_option_consume(options, :use_root_path)
-
-    raise(CloudinaryException, "URL Suffix only supported in private CDN") if url_suffix.present? and not private_cdn
-
-    original_source = source
-    return original_source if source.blank?
-    if defined?(CarrierWave::Uploader::Base) && source.is_a?(CarrierWave::Uploader::Base)
-      source = format.blank? ? source.filename : source.full_public_id
-    end
-    source = source.to_s
-    if !force_remote
-      return original_source if (type.nil? || type == :asset) && source.match(%r(^https?:/)i)
-      if source.start_with?("/")
-        if source.start_with?("/images/")
-          source = source.sub(%r(/images/), '')
-        else
-          return original_source
-        end
-      end
-      @metadata ||= defined?(Cloudinary::Static) ? Cloudinary::Static.metadata : {}
-      if type == :asset && @metadata["images/#{source}"]
-        return original_source if !Cloudinary.config.static_image_support
-        source = @metadata["images/#{source}"]["public_id"]
-        source += File.extname(original_source) if !format
-      elsif type == :asset
-        return original_source # requested asset, but no metadata - probably local file. return.
-      end
-    end
-
-    resource_type, type = finalize_resource_type(resource_type, type, url_suffix, use_root_path, shorten)
-    source, source_to_sign = finalize_source(source, format, url_suffix)
-
-    version ||= 1 if source_to_sign.include?("/") and !source_to_sign.match(/^v[0-9]+/) and !source_to_sign.match(/^https?:\//)
-    version &&= "v#{version}"
-
-    transformation = transformation.gsub(%r(([^:])//), '\1/')
-    if sign_url
-      to_sign = [transformation, sign_version && version, source_to_sign].reject(&:blank?).join("/")
-      signature = 's--' + Base64.urlsafe_encode64(Digest::SHA1.digest(to_sign + secret))[0,8] + '--'
-    end
-
-    prefix = unsigned_download_url_prefix(source, cloud_name, private_cdn, cdn_subdomain, secure_cdn_subdomain, cname, secure, secure_distribution)
-    source = [prefix, resource_type, type, signature, transformation, version, source].reject(&:blank?).join("/")
-  end
-
-  def self.finalize_source(source, format, url_suffix)
-    source = source.gsub(%r(([^:])//), '\1/')
-    if source.match(%r(^https?:/)i)
-      source = smart_escape(source)
-      source_to_sign = source
-    else
-      source = smart_escape(URI.decode(source))
-      source_to_sign = source
-      unless url_suffix.blank?
-        raise(CloudinaryException, "url_suffix should not include . or /") if url_suffix.match(%r([\./]))
-        source = "#{source}/#{url_suffix}"
-      end
-      if !format.blank?
-        source = "#{source}.#{format}"
-        source_to_sign = "#{source_to_sign}.#{format}"
-      end
-    end
-    [source, source_to_sign]
-  end
-
-  def self.finalize_resource_type(resource_type, type, url_suffix, use_root_path, shorten)
-    type ||= :upload
-    if !url_suffix.blank?
-      if resource_type.to_s == "image" && type.to_s == "upload"
-        resource_type = "images"
-        type = nil
-      elsif resource_type.to_s == "raw" && type.to_s == "upload"
-        resource_type = "files"
-        type = nil
-      else
-        raise(CloudinaryException, "URL Suffix only supported for image/upload and raw/upload")
-      end
-    end
-    if use_root_path
-      if (resource_type.to_s == "image" && type.to_s == "upload") || (resource_type.to_s == "images" && type.blank?)
-        resource_type = nil
-        type = nil
-      else
-        raise(CloudinaryException, "Root path only supported for image/upload")
-      end
-    end
-    if shorten && resource_type.to_s == "image" && type.to_s == "upload"
-      resource_type = "iu"
-      type = nil
-    end
-    [resource_type, type]
-  end
-
-  # cdn_subdomain and secure_cdn_subdomain
-  # 1) Customers in shared distribution (e.g. res.cloudinary.com)
-  #   if cdn_domain is true uses res-[1-5].cloudinary.com for both http and https. Setting secure_cdn_subdomain to false disables this for https.
-  # 2) Customers with private cdn
-  #   if cdn_domain is true uses cloudname-res-[1-5].cloudinary.com for http
-  #   if secure_cdn_domain is true uses cloudname-res-[1-5].cloudinary.com for https (please contact support if you require this)
-  # 3) Customers with cname
-  #   if cdn_domain is true uses a[1-5].cname for http. For https, uses the same naming scheme as 1 for shared distribution and as 2 for private distribution.
-  def self.unsigned_download_url_prefix(source, cloud_name, private_cdn, cdn_subdomain, secure_cdn_subdomain, cname, secure, secure_distribution)
-    return "/res#{cloud_name}" if cloud_name.start_with?("/") # For development
-
-    shared_domain = !private_cdn
-
-    if secure
-      if secure_distribution.nil? || secure_distribution == Cloudinary::OLD_AKAMAI_SHARED_CDN
-        secure_distribution = private_cdn ? "#{cloud_name}-res.cloudinary.com" : Cloudinary::SHARED_CDN
-      end
-      shared_domain ||= secure_distribution == Cloudinary::SHARED_CDN
-      secure_cdn_subdomain = cdn_subdomain if secure_cdn_subdomain.nil? && shared_domain
-
-      if secure_cdn_subdomain
-        secure_distribution = secure_distribution.gsub('res.cloudinary.com', "res-#{(Zlib::crc32(source) % 5) + 1}.cloudinary.com")
-      end
-
-      prefix = "https://#{secure_distribution}"
-    elsif cname
-      subdomain = cdn_subdomain ? "a#{(Zlib::crc32(source) % 5) + 1}." : ""
-      prefix = "http://#{subdomain}#{cname}"
-    else
-      host = [private_cdn ? "#{cloud_name}-" : "", "res", cdn_subdomain ? "-#{(Zlib::crc32(source) % 5) + 1}" : "", ".cloudinary.com"].join
-      prefix = "http://#{host}"
-    end
-    prefix += "/#{cloud_name}" if shared_domain
-
-    prefix
-  end
-
-  def self.cloudinary_api_url(action = 'upload', options = {})
-    cloudinary = options[:upload_prefix] || Cloudinary.config.upload_prefix || "https://api.cloudinary.com"
-    cloud_name = options[:cloud_name] || Cloudinary.config.cloud_name || raise(CloudinaryException, "Must supply cloud_name")
-    resource_type = options[:resource_type] || "image"
-    return [cloudinary, "v1_1", cloud_name, resource_type, action].join("/")
-  end
-
-  def self.sign_request(params, options={})
-    api_key = options[:api_key] || Cloudinary.config.api_key || raise(CloudinaryException, "Must supply api_key")
-    api_secret = options[:api_secret] || Cloudinary.config.api_secret || raise(CloudinaryException, "Must supply api_secret")
-    params = params.reject{|k, v| self.safe_blank?(v)}
-    params[:signature] = Cloudinary::Utils.api_sign_request(params, api_secret)
-    params[:api_key] = api_key
-    params
-  end
-
-  def self.private_download_url(public_id, format, options = {})
-    cloudinary_params = sign_request({
-        :timestamp=>Time.now.to_i,
-        :public_id=>public_id,
-        :format=>format,
-        :type=>options[:type],
-        :attachment=>options[:attachment],
-        :expires_at=>options[:expires_at] && options[:expires_at].to_i
-      }, options)
-
-    return Cloudinary::Utils.cloudinary_api_url("download", options) + "?" + cloudinary_params.to_query
-  end
-
-  def self.zip_download_url(tag, options = {})
-    cloudinary_params = sign_request({:timestamp=>Time.now.to_i, :tag=>tag, :transformation=>generate_transformation_string(options)}, options)
-    return Cloudinary::Utils.cloudinary_api_url("download_tag.zip", options) + "?" + cloudinary_params.to_query
-  end
-
-  def self.signed_download_url(public_id, options = {})
-    aws_private_key_path = options[:aws_private_key_path] || Cloudinary.config.aws_private_key_path || raise(CloudinaryException, "Must supply aws_private_key_path")
-    aws_key_pair_id = options[:aws_key_pair_id] || Cloudinary.config.aws_key_pair_id || raise(CloudinaryException, "Must supply aws_key_pair_id")
-    authenticated_distribution = options[:authenticated_distribution] || Cloudinary.config.authenticated_distribution || raise(CloudinaryException, "Must supply authenticated_distribution")
-    @signers ||= Hash.new{|h,k| path, id = k; h[k] = AwsCfSigner.new(path, id)}
-    signer = @signers[[aws_private_key_path, aws_key_pair_id]]
-    url = Cloudinary::Utils.unsigned_download_url(public_id, {:type=>:authenticated}.merge(options).merge(:secure=>true, :secure_distribution=>authenticated_distribution, :private_cdn=>true))
-    expires_at = options[:expires_at] || (Time.now+3600)
-    signer.sign(url, :ending => expires_at)
-  end
-
-  def self.cloudinary_url(public_id, options = {})
-    if options[:type].to_s == 'authenticated' && !options[:sign_url]
-      result = signed_download_url(public_id, options)
-    else
-      result = unsigned_download_url(public_id, options)
-    end
-    return result
-  end
-
-  def self.asset_file_name(path)
-    data = Cloudinary.app_root.join(path).read(:mode=>"rb")
-    ext = path.extname
-    md5 = Digest::MD5.hexdigest(data)
-    public_id = "#{path.basename(ext)}-#{md5}"
-    "#{public_id}#{ext}"
-  end
-
-  # Based on CGI::unescape. In addition does not escape / :
-  def self.smart_escape(string)
-    string.gsub(/([^a-zA-Z0-9_.\-\/:]+)/) do
-      '%' + $1.unpack('H2' * $1.bytesize).join('%').upcase
-    end
-  end
-
-  def self.random_public_id
-    sr = defined?(ActiveSupport::SecureRandom) ? ActiveSupport::SecureRandom : SecureRandom
-    sr.base64(20).downcase.gsub(/[^a-z0-9]/, "").sub(/^[0-9]+/, '')[0,20]
-  end
-
-  def self.signed_preloaded_image(result)
-    "#{result["resource_type"]}/#{result["type"] || "upload"}/v#{result["version"]}/#{[result["public_id"], result["format"]].reject(&:blank?).join(".")}##{result["signature"]}"
-  end
-
-  @@json_decode = false
-  def self.json_decode(str)
-    if !@@json_decode
-      @@json_decode = true
-      begin
-        require 'json'
-      rescue LoadError
-        begin
-          require 'active_support/json'
-        rescue LoadError
-          raise LoadError, "Please add the json gem or active_support to your Gemfile"
-        end
-      end
-    end
-    defined?(JSON) ? JSON.parse(str) : ActiveSupport::JSON.decode(str)
-  end
-
-  def self.build_array(array)
-    case array
-      when Array then array
-      when nil then []
-      else [array]
-    end
-  end
-
-  def self.encode_hash(hash)
-    case hash
-      when Hash then hash.map{|k,v| "#{k}=#{v}"}.join("|")
-      when nil then ""
-      else hash
-    end
-  end
-
-  def self.encode_double_array(array)
-    array = build_array(array)
-    if array.length > 0 && array[0].is_a?(Array)
-      return array.map{|a| build_array(a).join(",")}.join("|")
-    else
-      return array.join(",")
-    end
-  end
-
-  IMAGE_FORMATS = %w(bmp png tif tiff jpg jpeg gif pdf ico eps jpc jp2 psd)
-
-  def self.supported_image_format?(format)
-    format = format.to_s.downcase
-    extension = format =~ /\./ ? format.split('.').last : format
-    IMAGE_FORMATS.include?(extension)
-  end
-
-  def self.resource_type_for_format(format)
-    self.supported_image_format?(format) ? 'image' : 'raw'
-  end
-
-  def self.config_option_consume(options, option_name, default_value = nil)
-    return options.delete(option_name) if options.include?(option_name)
-    return Cloudinary.config.send(option_name) || default_value
-  end
-
-  def self.as_bool(value)
-    case value
-    when nil then nil
-    when String then value.downcase == "true" || value == "1"
-    when TrueClass then true
-    when FalseClass then false
-    when Fixnum then value != 0
-    when Symbol then value == :true
-    else
-      raise "Invalid boolean value #{value} of type #{value.class}"
-    end
-  end
-
-  def self.as_safe_bool(value)
-    case as_bool(value)
-    when nil then nil
-    when TrueClass then 1
-    when FalseClass then 0
-    end
-  end
-
-  def self.safe_blank?(value)
-    value.nil? || value == "" || value == []
-  end
-
-  private
-  def self.number_pattern
-    "([0-9]*)\\.([0-9]+)|([0-9]+)"
-  end
-
-  def self.offset_any_pattern
-    "(#{number_pattern})([%pP])?"
-  end
-
-  def self.offset_any_pattern_re
-    /((([0-9]*)\.([0-9]+)|([0-9]+))([%pP])?)\.\.((([0-9]*)\.([0-9]+)|([0-9]+))([%pP])?)/
-  end
-
-  # Split a range into the start and end values
-  def self.split_range(range) # :nodoc:
-    case range
-    when Range
-      [range.first, range.last]
-    when String
-      range.split ".." if offset_any_pattern_re =~ range
-    when Array
-      [range.first, range.last]
-    else
-      nil
-    end
-  end
-
-  # Normalize an offset value
-  # @param [String] value a decimal value which may have a 'p' or '%' postfix. E.g. '35%', '0.4p'
-  # @return [Object|String] a normalized String of the input value if possible otherwise the value itself
-  def self.norm_range_value(value) # :nodoc:
-    offset = /^#{offset_any_pattern}$/.match( value.to_s)
-    if offset
-      modifier   = offset[5].present? ? 'p' : ''
-      value  = "#{offset[1]}#{modifier}"
-    end
-    value
-  end
-
-  # A video codec parameter can be either a String or a Hash.
-  #
-  # @param [Object] param <code>vc_<codec>[ : <profile> : [<level>]]</code>
-  #                       or <code>{ codec: 'h264', profile: 'basic', level: '3.1' }</code>
-  # @return [String] <code><codec> : <profile> : [<level>]]</code> if a Hash was provided
-  #                   or the param if a String was provided.
-  #                   Returns NIL if param is not a Hash or String
-  def self.process_video_params(param)
-    case param
-    when Hash
-      video = ""
-      if param.has_key? :codec
-        video = param[:codec]
-        if param.has_key? :profile
-          video.concat ":" + param[:profile]
-          if param.has_key? :level
-            video.concat ":" + param[:level]
-          end
-        end
-      end
-      video
-    when String
-      param
-    else
-      nil
-    end
-  end
-
-  def self.deep_symbolize_keys(object)
-    case object
-    when Hash
-      result = {}
-      object.each do |key, value|
-        key = key.to_sym rescue key
-        result[key] = deep_symbolize_keys(value)
-      end
-      result
-    when Array
-      object.map{|e| deep_symbolize_keys(e)}
-    else
-      object
-    end
-  end
-
-end
+# Copyright Cloudinary
+require 'digest/sha1'
+require 'zlib'
+require 'uri'
+require 'aws_cf_signer'
+
+class Cloudinary::Utils
+  # @deprecated Use Cloudinary::SHARED_CDN
+  SHARED_CDN = Cloudinary::SHARED_CDN
+  DEFAULT_RESPONSIVE_WIDTH_TRANSFORMATION = {:width => :auto, :crop => :limit}
+
+  # Warning: options are being destructively updated!
+  def self.generate_transformation_string(options={})
+    if options.is_a?(Array)
+      return options.map{|base_transformation| generate_transformation_string(base_transformation.clone)}.join("/")
+    end
+    # Symbolize keys
+    options.keys.each do |key|
+      options[(key.to_sym rescue key)] = options.delete(key)
+    end
+    
+    responsive_width = config_option_consume(options, :responsive_width) 
+    size = options.delete(:size)
+    options[:width], options[:height] = size.split("x") if size
+    width = options[:width]
+    width = width.to_s if width.is_a?(Symbol)
+    height = options[:height]
+    has_layer = options[:overlay].present? || options[:underlay].present?
+
+    crop = options.delete(:crop)
+    angle = build_array(options.delete(:angle)).join(".")
+
+    no_html_sizes = has_layer || angle.present? || crop.to_s == "fit" || crop.to_s == "limit" || crop.to_s == "lfill"
+    options.delete(:width) if width && (width.to_f < 1 || no_html_sizes || width == "auto" || responsive_width)
+    options.delete(:height) if height && (height.to_f < 1 || no_html_sizes || responsive_width)
+
+    width=height=nil if crop.nil? && !has_layer && width != "auto"
+
+    background = options.delete(:background)
+    background = background.sub(/^#/, 'rgb:') if background
+
+    color = options.delete(:color)
+    color = color.sub(/^#/, 'rgb:') if color
+
+    base_transformations = build_array(options.delete(:transformation))
+    if base_transformations.any?{|base_transformation| base_transformation.is_a?(Hash)}
+      base_transformations = base_transformations.map do
+        |base_transformation|
+        base_transformation.is_a?(Hash) ? generate_transformation_string(base_transformation.clone) : generate_transformation_string(:transformation=>base_transformation)
+      end
+    else
+      named_transformation = base_transformations.join(".")
+      base_transformations = []
+    end
+
+    effect = options.delete(:effect)
+    effect = Array(effect).flatten.join(":") if effect.is_a?(Array) || effect.is_a?(Hash)
+
+    border = options.delete(:border)
+    if border.is_a?(Hash)
+      border = "#{border[:width] || 2}px_solid_#{(border[:color] || "black").sub(/^#/, 'rgb:')}"
+    elsif border.to_s =~ /^\d+$/ # fallback to html border attribute
+      options[:border] = border
+      border = nil
+    end
+    flags = build_array(options.delete(:flags)).join(".")
+    dpr = config_option_consume(options, :dpr)
+
+    if options.include? :offset
+      options[:start_offset], options[:end_offset] = split_range options.delete(:offset)
+    end
+
+    params = {
+      :a   => angle,
+      :b   => background,
+      :bo  => border,
+      :c   => crop,
+      :co  => color,
+      :dpr => dpr,
+      :e   => effect,
+      :fl  => flags,
+      :h   => height,
+      :t   => named_transformation,
+      :w   => width
+    }
+    {
+      :ac => :audio_codec,
+      :br => :bit_rate,
+      :cs => :color_space,
+      :d  => :default_image,
+      :dl => :delay,
+      :dn => :density,
+      :du => :duration,
+      :eo => :end_offset,
+      :f  => :fetch_format,
+      :g  => :gravity,
+      :l  => :overlay,
+      :o  => :opacity,
+      :p  => :prefix,
+      :pg => :page,
+      :q  => :quality,
+      :r  => :radius,
+      :af => :audio_frequency,
+      :so => :start_offset,
+      :u  => :underlay,
+      :vc => :video_codec,
+      :vs => :video_sampling,
+      :x  => :x,
+      :y  => :y,
+      :z  => :zoom
+    }.each do
+      |param, option|
+      params[param] = options.delete(option)
+    end
+
+    params[:vc] = process_video_params params[:vc] if params[:vc].present?
+    [:so, :eo, :du].each do |range_value|
+      params[range_value] = norm_range_value params[range_value] if params[range_value].present?
+    end
+
+    transformation = params.reject{|_k,v| v.blank?}.map{|k,v| "#{k}_#{v}"}.sort.join(",")
+    raw_transformation = options.delete(:raw_transformation)
+    transformation = [transformation, raw_transformation].reject(&:blank?).join(",")
+    transformations = base_transformations << transformation
+    if responsive_width
+      responsive_width_transformation = Cloudinary.config.responsive_width_transformation || DEFAULT_RESPONSIVE_WIDTH_TRANSFORMATION
+      transformations << generate_transformation_string(responsive_width_transformation.clone)
+    end
+
+    if width.to_s == "auto" || responsive_width
+      options[:responsive] = true
+    end
+    if dpr.to_s == "auto"
+      options[:hidpi] = true
+    end
+
+    transformations.reject(&:blank?).join("/")
+  end
+
+  def self.api_string_to_sign(params_to_sign)
+    params_to_sign.map{|k,v| [k.to_s, v.is_a?(Array) ? v.join(",") : v]}.reject{|k,v| v.nil? || v == ""}.sort_by(&:first).map{|k,v| "#{k}=#{v}"}.join("&")
+  end
+
+  def self.api_sign_request(params_to_sign, api_secret)
+    to_sign = api_string_to_sign(params_to_sign)
+    Digest::SHA1.hexdigest("#{to_sign}#{api_secret}")
+  end
+
+  # Warning: options are being destructively updated!
+  def self.unsigned_download_url(source, options = {})
+
+    type = options.delete(:type)
+
+    options[:fetch_format] ||= options.delete(:format) if type == :fetch
+    transformation = self.generate_transformation_string(options)
+
+    resource_type = options.delete(:resource_type)
+    version = options.delete(:version)
+    format = options.delete(:format)
+    cloud_name = config_option_consume(options, :cloud_name) || raise(CloudinaryException, "Must supply cloud_name in tag or in configuration")
+
+    secure = options.delete(:secure)
+    ssl_detected = options.delete(:ssl_detected)
+    secure = ssl_detected || Cloudinary.config.secure if secure.nil?
+    private_cdn = config_option_consume(options, :private_cdn)
+    secure_distribution = config_option_consume(options, :secure_distribution)
+    cname = config_option_consume(options, :cname)
+    shorten = config_option_consume(options, :shorten)
+    force_remote = options.delete(:force_remote)
+    cdn_subdomain = config_option_consume(options, :cdn_subdomain)
+    secure_cdn_subdomain = config_option_consume(options, :secure_cdn_subdomain)
+    sign_url = config_option_consume(options, :sign_url)
+    secret = config_option_consume(options, :api_secret)
+    sign_version = config_option_consume(options, :sign_version) # Deprecated behavior
+    url_suffix = options.delete(:url_suffix)
+    use_root_path = config_option_consume(options, :use_root_path)
+
+    raise(CloudinaryException, "URL Suffix only supported in private CDN") if url_suffix.present? and not private_cdn
+
+    original_source = source
+    return original_source if source.blank?
+    if defined?(CarrierWave::Uploader::Base) && source.is_a?(CarrierWave::Uploader::Base)
+      resource_type ||= source.resource_type
+      type ||= source.storage_type
+      source = format.blank? ? source.filename : source.full_public_id
+    end
+    resource_type ||= "image"
+    source = source.to_s
+    if !force_remote
+      return original_source if (type.nil? || type == :asset) && source.match(%r(^https?:/)i)
+      if source.start_with?("/")
+        if source.start_with?("/images/")
+          source = source.sub(%r(/images/), '')
+        else
+          return original_source
+        end
+      end
+      @metadata ||= defined?(Cloudinary::Static) ? Cloudinary::Static.metadata : {}
+      if type == :asset && @metadata["images/#{source}"]
+        return original_source if !Cloudinary.config.static_image_support
+        source = @metadata["images/#{source}"]["public_id"]
+        source += File.extname(original_source) if !format
+      elsif type == :asset
+        return original_source # requested asset, but no metadata - probably local file. return.
+      end
+    end
+
+    resource_type, type = finalize_resource_type(resource_type, type, url_suffix, use_root_path, shorten)
+    source, source_to_sign = finalize_source(source, format, url_suffix)
+
+    version ||= 1 if source_to_sign.include?("/") and !source_to_sign.match(/^v[0-9]+/) and !source_to_sign.match(/^https?:\//)
+    version &&= "v#{version}"
+
+    transformation = transformation.gsub(%r(([^:])//), '\1/')
+    if sign_url
+      to_sign = [transformation, sign_version && version, source_to_sign].reject(&:blank?).join("/")
+      signature = 's--' + Base64.urlsafe_encode64(Digest::SHA1.digest(to_sign + secret))[0,8] + '--'
+    end
+
+    prefix = unsigned_download_url_prefix(source, cloud_name, private_cdn, cdn_subdomain, secure_cdn_subdomain, cname, secure, secure_distribution)
+    source = [prefix, resource_type, type, signature, transformation, version, source].reject(&:blank?).join("/")
+  end
+
+  def self.finalize_source(source, format, url_suffix)
+    source = source.gsub(%r(([^:])//), '\1/')
+    if source.match(%r(^https?:/)i)
+      source = smart_escape(source)
+      source_to_sign = source
+    else
+      source = smart_escape(URI.decode(source))
+      source_to_sign = source
+      unless url_suffix.blank?
+        raise(CloudinaryException, "url_suffix should not include . or /") if url_suffix.match(%r([\./]))
+        source = "#{source}/#{url_suffix}"
+      end
+      if !format.blank?
+        source = "#{source}.#{format}"
+        source_to_sign = "#{source_to_sign}.#{format}"
+      end
+    end
+    [source, source_to_sign]
+  end
+
+  def self.finalize_resource_type(resource_type, type, url_suffix, use_root_path, shorten)
+    type ||= :upload
+    if !url_suffix.blank?
+      if resource_type.to_s == "image" && type.to_s == "upload"
+        resource_type = "images"
+        type = nil
+      elsif resource_type.to_s == "raw" && type.to_s == "upload"
+        resource_type = "files"
+        type = nil
+      else
+        raise(CloudinaryException, "URL Suffix only supported for image/upload and raw/upload")
+      end
+    end
+    if use_root_path
+      if (resource_type.to_s == "image" && type.to_s == "upload") || (resource_type.to_s == "images" && type.blank?)
+        resource_type = nil
+        type = nil
+      else
+        raise(CloudinaryException, "Root path only supported for image/upload")
+      end
+    end
+    if shorten && resource_type.to_s == "image" && type.to_s == "upload"
+      resource_type = "iu"
+      type = nil
+    end
+    [resource_type, type]
+  end
+
+  # cdn_subdomain and secure_cdn_subdomain
+  # 1) Customers in shared distribution (e.g. res.cloudinary.com)
+  #   if cdn_domain is true uses res-[1-5].cloudinary.com for both http and https. Setting secure_cdn_subdomain to false disables this for https.
+  # 2) Customers with private cdn
+  #   if cdn_domain is true uses cloudname-res-[1-5].cloudinary.com for http
+  #   if secure_cdn_domain is true uses cloudname-res-[1-5].cloudinary.com for https (please contact support if you require this)
+  # 3) Customers with cname
+  #   if cdn_domain is true uses a[1-5].cname for http. For https, uses the same naming scheme as 1 for shared distribution and as 2 for private distribution.
+  def self.unsigned_download_url_prefix(source, cloud_name, private_cdn, cdn_subdomain, secure_cdn_subdomain, cname, secure, secure_distribution)
+    return "/res#{cloud_name}" if cloud_name.start_with?("/") # For development
+
+    shared_domain = !private_cdn
+
+    if secure
+      if secure_distribution.nil? || secure_distribution == Cloudinary::OLD_AKAMAI_SHARED_CDN
+        secure_distribution = private_cdn ? "#{cloud_name}-res.cloudinary.com" : Cloudinary::SHARED_CDN
+      end
+      shared_domain ||= secure_distribution == Cloudinary::SHARED_CDN
+      secure_cdn_subdomain = cdn_subdomain if secure_cdn_subdomain.nil? && shared_domain
+
+      if secure_cdn_subdomain
+        secure_distribution = secure_distribution.gsub('res.cloudinary.com', "res-#{(Zlib::crc32(source) % 5) + 1}.cloudinary.com")
+      end
+
+      prefix = "https://#{secure_distribution}"
+    elsif cname
+      subdomain = cdn_subdomain ? "a#{(Zlib::crc32(source) % 5) + 1}." : ""
+      prefix = "http://#{subdomain}#{cname}"
+    else
+      host = [private_cdn ? "#{cloud_name}-" : "", "res", cdn_subdomain ? "-#{(Zlib::crc32(source) % 5) + 1}" : "", ".cloudinary.com"].join
+      prefix = "http://#{host}"
+    end
+    prefix += "/#{cloud_name}" if shared_domain
+
+    prefix
+  end
+
+  def self.cloudinary_api_url(action = 'upload', options = {})
+    cloudinary = options[:upload_prefix] || Cloudinary.config.upload_prefix || "https://api.cloudinary.com"
+    cloud_name = options[:cloud_name] || Cloudinary.config.cloud_name || raise(CloudinaryException, "Must supply cloud_name")
+    resource_type = options[:resource_type] || "image"
+    return [cloudinary, "v1_1", cloud_name, resource_type, action].join("/")
+  end
+
+  def self.sign_request(params, options={})
+    api_key = options[:api_key] || Cloudinary.config.api_key || raise(CloudinaryException, "Must supply api_key")
+    api_secret = options[:api_secret] || Cloudinary.config.api_secret || raise(CloudinaryException, "Must supply api_secret")
+    params = params.reject{|k, v| self.safe_blank?(v)}
+    params[:signature] = Cloudinary::Utils.api_sign_request(params, api_secret)
+    params[:api_key] = api_key
+    params
+  end
+
+  def self.private_download_url(public_id, format, options = {})
+    cloudinary_params = sign_request({
+        :timestamp=>Time.now.to_i,
+        :public_id=>public_id,
+        :format=>format,
+        :type=>options[:type],
+        :attachment=>options[:attachment],
+        :expires_at=>options[:expires_at] && options[:expires_at].to_i
+      }, options)
+
+    return Cloudinary::Utils.cloudinary_api_url("download", options) + "?" + cloudinary_params.to_query
+  end
+
+  def self.zip_download_url(tag, options = {})
+    cloudinary_params = sign_request({:timestamp=>Time.now.to_i, :tag=>tag, :transformation=>generate_transformation_string(options)}, options)
+    return Cloudinary::Utils.cloudinary_api_url("download_tag.zip", options) + "?" + cloudinary_params.to_query
+  end
+
+  def self.signed_download_url(public_id, options = {})
+    aws_private_key_path = options[:aws_private_key_path] || Cloudinary.config.aws_private_key_path || raise(CloudinaryException, "Must supply aws_private_key_path")
+    aws_key_pair_id = options[:aws_key_pair_id] || Cloudinary.config.aws_key_pair_id || raise(CloudinaryException, "Must supply aws_key_pair_id")
+    authenticated_distribution = options[:authenticated_distribution] || Cloudinary.config.authenticated_distribution || raise(CloudinaryException, "Must supply authenticated_distribution")
+    @signers ||= Hash.new{|h,k| path, id = k; h[k] = AwsCfSigner.new(path, id)}
+    signer = @signers[[aws_private_key_path, aws_key_pair_id]]
+    url = Cloudinary::Utils.unsigned_download_url(public_id, {:type=>:authenticated}.merge(options).merge(:secure=>true, :secure_distribution=>authenticated_distribution, :private_cdn=>true))
+    expires_at = options[:expires_at] || (Time.now+3600)
+    signer.sign(url, :ending => expires_at)
+  end
+
+  def self.cloudinary_url(public_id, options = {})
+    if options[:type].to_s == 'authenticated' && !options[:sign_url]
+      result = signed_download_url(public_id, options)
+    else
+      result = unsigned_download_url(public_id, options)
+    end
+    return result
+  end
+
+  def self.asset_file_name(path)
+    data = Cloudinary.app_root.join(path).read(:mode=>"rb")
+    ext = path.extname
+    md5 = Digest::MD5.hexdigest(data)
+    public_id = "#{path.basename(ext)}-#{md5}"
+    "#{public_id}#{ext}"
+  end
+
+  # Based on CGI::unescape. In addition does not escape / :
+  def self.smart_escape(string)
+    string.gsub(/([^a-zA-Z0-9_.\-\/:]+)/) do
+      '%' + $1.unpack('H2' * $1.bytesize).join('%').upcase
+    end
+  end
+
+  def self.random_public_id
+    sr = defined?(ActiveSupport::SecureRandom) ? ActiveSupport::SecureRandom : SecureRandom
+    sr.base64(20).downcase.gsub(/[^a-z0-9]/, "").sub(/^[0-9]+/, '')[0,20]
+  end
+
+  def self.signed_preloaded_image(result)
+    "#{result["resource_type"]}/#{result["type"] || "upload"}/v#{result["version"]}/#{[result["public_id"], result["format"]].reject(&:blank?).join(".")}##{result["signature"]}"
+  end
+
+  @@json_decode = false
+  def self.json_decode(str)
+    if !@@json_decode
+      @@json_decode = true
+      begin
+        require 'json'
+      rescue LoadError
+        begin
+          require 'active_support/json'
+        rescue LoadError
+          raise LoadError, "Please add the json gem or active_support to your Gemfile"
+        end
+      end
+    end
+    defined?(JSON) ? JSON.parse(str) : ActiveSupport::JSON.decode(str)
+  end
+
+  def self.build_array(array)
+    case array
+      when Array then array
+      when nil then []
+      else [array]
+    end
+  end
+
+  def self.encode_hash(hash)
+    case hash
+      when Hash then hash.map{|k,v| "#{k}=#{v}"}.join("|")
+      when nil then ""
+      else hash
+    end
+  end
+
+  def self.encode_double_array(array)
+    array = build_array(array)
+    if array.length > 0 && array[0].is_a?(Array)
+      return array.map{|a| build_array(a).join(",")}.join("|")
+    else
+      return array.join(",")
+    end
+  end
+
+  IMAGE_FORMATS = %w(bmp png tif tiff jpg jpeg gif pdf ico eps jpc jp2 psd)
+
+  def self.supported_image_format?(format)
+    format = format.to_s.downcase
+    extension = format =~ /\./ ? format.split('.').last : format
+    IMAGE_FORMATS.include?(extension)
+  end
+
+  def self.resource_type_for_format(format)
+    self.supported_image_format?(format) ? 'image' : 'raw'
+  end
+
+  def self.config_option_consume(options, option_name, default_value = nil)
+    return options.delete(option_name) if options.include?(option_name)
+    return Cloudinary.config.send(option_name) || default_value
+  end
+
+  def self.as_bool(value)
+    case value
+    when nil then nil
+    when String then value.downcase == "true" || value == "1"
+    when TrueClass then true
+    when FalseClass then false
+    when Fixnum then value != 0
+    when Symbol then value == :true
+    else
+      raise "Invalid boolean value #{value} of type #{value.class}"
+    end
+  end
+
+  def self.as_safe_bool(value)
+    case as_bool(value)
+    when nil then nil
+    when TrueClass then 1
+    when FalseClass then 0
+    end
+  end
+
+  def self.safe_blank?(value)
+    value.nil? || value == "" || value == []
+  end
+
+  private
+  def self.number_pattern
+    "([0-9]*)\\.([0-9]+)|([0-9]+)"
+  end
+
+  def self.offset_any_pattern
+    "(#{number_pattern})([%pP])?"
+  end
+
+  def self.offset_any_pattern_re
+    /((([0-9]*)\.([0-9]+)|([0-9]+))([%pP])?)\.\.((([0-9]*)\.([0-9]+)|([0-9]+))([%pP])?)/
+  end
+
+  # Split a range into the start and end values
+  def self.split_range(range) # :nodoc:
+    case range
+    when Range
+      [range.first, range.last]
+    when String
+      range.split ".." if offset_any_pattern_re =~ range
+    when Array
+      [range.first, range.last]
+    else
+      nil
+    end
+  end
+
+  # Normalize an offset value
+  # @param [String] value a decimal value which may have a 'p' or '%' postfix. E.g. '35%', '0.4p'
+  # @return [Object|String] a normalized String of the input value if possible otherwise the value itself
+  def self.norm_range_value(value) # :nodoc:
+    offset = /^#{offset_any_pattern}$/.match( value.to_s)
+    if offset
+      modifier   = offset[5].present? ? 'p' : ''
+      value  = "#{offset[1]}#{modifier}"
+    end
+    value
+  end
+
+  # A video codec parameter can be either a String or a Hash.
+  #
+  # @param [Object] param <code>vc_<codec>[ : <profile> : [<level>]]</code>
+  #                       or <code>{ codec: 'h264', profile: 'basic', level: '3.1' }</code>
+  # @return [String] <code><codec> : <profile> : [<level>]]</code> if a Hash was provided
+  #                   or the param if a String was provided.
+  #                   Returns NIL if param is not a Hash or String
+  def self.process_video_params(param)
+    case param
+    when Hash
+      video = ""
+      if param.has_key? :codec
+        video = param[:codec]
+        if param.has_key? :profile
+          video.concat ":" + param[:profile]
+          if param.has_key? :level
+            video.concat ":" + param[:level]
+          end
+        end
+      end
+      video
+    when String
+      param
+    else
+      nil
+    end
+  end
+
+  def self.deep_symbolize_keys(object)
+    case object
+    when Hash
+      result = {}
+      object.each do |key, value|
+        key = key.to_sym rescue key
+        result[key] = deep_symbolize_keys(value)
+      end
+      result
+    when Array
+      object.map{|e| deep_symbolize_keys(e)}
+    else
+      object
+    end
+  end
+
+end