cloudinary 1.0.82 → 1.0.83

data/lib/cloudinary/uploader.rb

@@ -71,7 +71,7 @@ class Cloudinary::Uploader
       params = build_upload_params(options)
       if file.is_a?(Pathname)
         params[:file] = File.open(file, "rb")
-      elsif file.respond_to?(:read) || file =~ /^https?:|^s3:|^data:[^;]*;base64,([a-zA-Z0-9\/+\n=]+)$/
+      elsif file.respond_to?(:read) || file =~ /^ftp:|^https?:|^s3:|^data:[^;]*;base64,([a-zA-Z0-9\/+\n=]+)$/
         params[:file] = file
       else 
         params[:file] = File.open(file, "rb")
@@ -80,7 +80,7 @@ class Cloudinary::Uploader
     end              
   end
 
-  # Upload large raw files. Note that public_id should include an extension for best results.
+  # Upload large files. Note that public_id should include an extension for best results.
   def self.upload_large(file, public_id_or_options={}, old_options={})
     if public_id_or_options.is_a?(Hash)
       options = public_id_or_options
@@ -96,11 +96,13 @@ class Cloudinary::Uploader
       filename = "cloudinaryfile"
     end
     upload = upload_id = nil
-    index = 1
+    index = 0
+    chunk_size = options[:chunk_size] || 20_000_000
     while !file.eof?
-      buffer = file.read(20_000_000)
-      upload = upload_large_part(Cloudinary::Blob.new(buffer, :original_filename=>filename), options.merge(:public_id=>public_id, :upload_id=>upload_id, :part_number=>index, :final=>file.eof?))
-      upload_id = upload["upload_id"]
+      buffer = file.read(chunk_size)
+      current_loc = index*chunk_size
+      range = "bytes #{current_loc}-#{current_loc+buffer.size - 1}/#{file.size}"
+      upload = upload_large_part(Cloudinary::Blob.new(buffer, :original_filename=>filename), options.merge(:public_id=>public_id, :content_range=>range))
       public_id = upload["public_id"]      
       index += 1
     end
@@ -108,19 +110,11 @@ class Cloudinary::Uploader
   end
     
 
-  # Upload large raw files. Note that public_id should include an extension for best results.
+  # Upload large  files. Note that public_id should include an extension for best results.
   def self.upload_large_part(file, options={})
-    call_api("upload_large", options.merge(:resource_type=>:raw)) do    
-      params = {
-        :timestamp=>(options[:timestamp] || Time.now.to_i),
-        :type=>options[:type],
-        :public_id=>options[:public_id],
-        :backup=>options[:backup],
-        :final=>options[:final],
-        :part_number=>options[:part_number],
-        :tags=>options[:tags] && Cloudinary::Utils.build_array(options[:tags]).join(","),
-        :upload_id=>options[:upload_id]
-      }
+    options[:resource_type] ||= :raw
+    call_api("upload_chunked", options) do    
+      params = build_upload_params(options)
       if file.is_a?(Pathname) || !file.respond_to?(:read)
         params[:file] = File.open(file, "rb")
       else
@@ -171,6 +165,8 @@ class Cloudinary::Uploader
         :public_id=> public_id,
         :callback=> options[:callback],
         :eager=>build_eager(options[:eager]),
+        :eager_notification_url=>options[:eager_notification_url],
+        :eager_async=>Cloudinary::Utils.as_safe_bool(options[:eager_async]),
         :headers=>build_custom_headers(options[:headers]),
         :tags=>options[:tags] && Cloudinary::Utils.build_array(options[:tags]).join(","),
         :face_coordinates => options[:face_coordinates] && Cloudinary::Utils.encode_double_array(options[:face_coordinates])  
@@ -277,12 +273,14 @@ class Cloudinary::Uploader
       params[:signature] = Cloudinary::Utils.api_sign_request(params.reject{|k,v| non_signable.include?(k)}, api_secret)
       params[:api_key] = api_key
     end
+    timeout = options[:timeout] || Cloudinary.config.timeout || 60
 
     result = nil
     
     api_url = Cloudinary::Utils.cloudinary_api_url(action, options)
-    
-    RestClient::Request.execute(:method => :post, :url => api_url, :payload => params.reject{|k, v| v.nil? || v==""}, :timeout=>60, :headers => {"User-Agent" => Cloudinary::USER_AGENT}) do
+    headers = {"User-Agent" => Cloudinary::USER_AGENT}
+    headers['Content-Range'] = options[:content_range] if options[:content_range]
+    RestClient::Request.execute(:method => :post, :url => api_url, :payload => params.reject{|k, v| v.nil? || v==""}, :timeout=> timeout, :headers => headers) do
       |response, request, tmpresult|
       raise CloudinaryException, "Server returned unexpected status code - #{response.code} - #{response.body}" if ![200,400,401,403,404,500].include?(response.code)
       begin

data/lib/cloudinary/utils.rb

@@ -6,9 +6,9 @@ require 'aws_cf_signer'
 
 class Cloudinary::Utils
   # @deprecated Use Cloudinary::SHARED_CDN
-  SHARED_CDN = 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)
@@ -16,21 +16,21 @@ class Cloudinary::Utils
     end
     # Symbolize keys
     options.keys.each do |key|
-      options[key.to_sym] = options.delete(key) if key.is_a?(String)
+      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    
+    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].blank? || !options[:underlay].blank?
-         
+    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.blank? || crop.to_s == "fit" || crop.to_s == "limit" || crop.to_s == "lfill"
+    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)
 
@@ -41,40 +41,84 @@ class Cloudinary::Utils
 
     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      
+    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 
+    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)
-    
-    params = {:w=>width, :h=>height, :t=>named_transformation, :c=>crop, :b=>background, :e=>effect, :a=>angle, :bo=>border, :fl=>flags, :co=>color, :dpr=>dpr}
-    { :x=>:x, :y=>:y, :r=>:radius, :d=>:default_image, :g=>:gravity, :q=>:quality, :cs=>:color_space, :o=>:opacity,
-      :p=>:prefix, :l=>:overlay, :u=>:underlay, :f=>:fetch_format, :dn=>:density, :pg=>:page, :dl=>:delay
+
+    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    
+    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.to_s, v]}.sort_by(&:first).map{|k,v| "#{k}_#{v}"}.join(",")
+    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
@@ -90,13 +134,13 @@ class Cloudinary::Utils
       options[:hidpi] = true
     end
 
-    transformations.reject(&:blank?).join("/")    
+    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}")
@@ -107,24 +151,24 @@ class Cloudinary::Utils
 
     type = options.delete(:type)
 
-    options[:fetch_format] ||= options.delete(:format) if type == :fetch 
+    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) 
+    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) 
+    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
@@ -136,33 +180,33 @@ class Cloudinary::Utils
     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 
+      source = format.blank? ? source.filename : source.full_public_id
     end
     source = source.to_s
-    if !force_remote    
+    if !force_remote
       return original_source if (type.nil? || type == :asset) && source.match(%r(^https?:/)i)
-      if source.start_with?("/") 
+      if source.start_with?("/")
         if source.start_with?("/images/")
           source = source.sub(%r(/images/), '')
         else
           return original_source
         end
-      end 
+      end
       @metadata ||= defined?(Cloudinary::Static) ? Cloudinary::Static.metadata : {}
       if type == :asset && @metadata["images/#{source}"]
-        return original_source if !Cloudinary.config.static_image_support        
+        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}" 
+
+    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
@@ -180,19 +224,19 @@ class Cloudinary::Utils
       source = smart_escape(source)
       source_to_sign = source
     else
-      source = smart_escape(URI.decode(source)) 
+      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}" 
+        source = "#{source}/#{url_suffix}"
       end
       if !format.blank?
-        source = "#{source}.#{format}" 
-        source_to_sign = "#{source_to_sign}.#{format}" 
+        source = "#{source}.#{format}"
+        source_to_sign = "#{source_to_sign}.#{format}"
       end
     end
     [source, source_to_sign]
-  end    
+  end
 
   def self.finalize_resource_type(resource_type, type, url_suffix, use_root_path, shorten)
     type ||= :upload
@@ -200,7 +244,7 @@ class Cloudinary::Utils
       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" 
+      elsif resource_type.to_s == "raw" && type.to_s == "upload"
         resource_type = "files"
         type = nil
       else
@@ -220,12 +264,12 @@ class Cloudinary::Utils
       type = nil
     end
     [resource_type, type]
-  end    
-  
+  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 
+  # 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
@@ -252,7 +296,7 @@ class Cloudinary::Utils
       prefix = "http://#{subdomain}#{cname}"
     else
       host = [private_cdn ? "#{cloud_name}-" : "", "res", cdn_subdomain ? "-#{(Zlib::crc32(source) % 5) + 1}" : "", ".cloudinary.com"].join
-      prefix = "http://#{host}"        
+      prefix = "http://#{host}"
     end
     prefix += "/#{cloud_name}" if shared_domain
 
@@ -274,23 +318,23 @@ class Cloudinary::Utils
     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, 
+        :timestamp=>Time.now.to_i,
+        :public_id=>public_id,
+        :format=>format,
         :type=>options[:type],
-        :attachment=>options[:attachment], 
+        :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 
+
+    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 
+    return Cloudinary::Utils.cloudinary_api_url("download_tag.zip", options) + "?" + cloudinary_params.to_query
   end
 
   def self.signed_download_url(public_id, options = {})
@@ -303,7 +347,7 @@ class Cloudinary::Utils
     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)
@@ -318,16 +362,16 @@ class Cloudinary::Utils
     ext = path.extname
     md5 = Digest::MD5.hexdigest(data)
     public_id = "#{path.basename(ext)}-#{md5}"
-    "#{public_id}#{ext}"    
+    "#{public_id}#{ext}"
   end
-  
-  # Based on CGI::unescape. In addition does not escape / : 
+
+  # 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]
@@ -336,7 +380,7 @@ class Cloudinary::Utils
   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
@@ -347,7 +391,7 @@ class Cloudinary::Utils
         begin
           require 'active_support/json'
         rescue LoadError
-          raise LoadError, "Please add the json gem or active_support to your Gemfile"            
+          raise LoadError, "Please add the json gem or active_support to your Gemfile"
         end
       end
     end
@@ -361,7 +405,7 @@ class Cloudinary::Utils
       else [array]
     end
   end
-    
+
   def self.encode_hash(hash)
     case hash
       when Hash then hash.map{|k,v| "#{k}=#{v}"}.join("|")
@@ -369,7 +413,7 @@ class Cloudinary::Utils
       else hash
     end
   end
-  
+
   def self.encode_double_array(array)
     array = build_array(array)
     if array.length > 0 && array[0].is_a?(Array)
@@ -378,24 +422,24 @@ class Cloudinary::Utils
       return array.join(",")
     end
   end
-  
-  IMAGE_FORMATS = %w(bmp png tif tiff jpg jpeg gif pdf ico eps jpc jp2 psd) 
-  
+
+  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)    
+
+  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    
+    return Cloudinary.config.send(option_name) || default_value
   end
-  
+
   def self.as_bool(value)
     case value
     when nil then nil
@@ -408,7 +452,7 @@ class Cloudinary::Utils
       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
@@ -416,8 +460,76 @@ class Cloudinary::Utils
     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
+
 end