cloudinary 1.9.1 → 1.20.0

data/lib/cloudinary/helper.rb

@@ -1,7 +1,11 @@
 require 'digest/md5'
 require 'cloudinary/video_helper'
+require 'cloudinary/responsive'
 
 module CloudinaryHelper
+  include ActionView::Helpers::CaptureHelper
+  include Responsive
+
   CL_BLANK = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7"
 
   # Stand-in for Rails image_tag helper that accepts various options for transformations.
@@ -37,13 +41,45 @@ module CloudinaryHelper
 
   end
 
+
+  def cl_picture_tag(source, options = {}, sources =[])
+
+    options = options.clone
+    content_tag 'picture' do
+      sources.map do |source_def|
+        source_options = options.clone
+        source_options = Cloudinary::Utils.chain_transformation(source_options, source_def[:transformation])
+        source_options[:media] = source_def
+        cl_source_tag(source, source_options)
+      end.push(cl_image_tag(source, options))
+          .join('')
+          .html_safe
+    end
+  end
+
+  def cl_source_tag(source, options)
+    srcset_param = options.fetch(:srcset, {}).merge(Cloudinary.config.srcset || {})
+    attributes = options.fetch(:attributes, {}).clone
+    responsive_attributes = generate_image_responsive_attributes(source, attributes, srcset_param, options)
+    attributes = attributes.merge(responsive_attributes)
+    unless attributes.has_key? :srcset
+      attributes[:srcset] = Cloudinary::Utils.cloudinary_url(source, options)
+    end
+    media_attr = generate_media_attribute(options[:media])
+    attributes[:media] = media_attr unless media_attr.empty?
+    tag "source", attributes, true
+  end
+
+
   def cloudinary_tag(source, options = {})
     tag_options = options.clone
     tag_options[:width] = tag_options.delete(:html_width) if tag_options.include?(:html_width)
     tag_options[:height] = tag_options.delete(:html_height) if tag_options.include?(:html_height)
     tag_options[:size] = tag_options.delete(:html_size) if tag_options.include?(:html_size)
     tag_options[:border] = tag_options.delete(:html_border) if tag_options.include?(:html_border)
-    source = cloudinary_url_internal(source, tag_options)
+    srcset_param = Cloudinary::Utils.config_option_consume(tag_options, :srcset, {})
+    src = cloudinary_url_internal(source, tag_options)
+    attributes = tag_options.delete(:attributes) || {}
 
     responsive_placeholder = Cloudinary::Utils.config_option_consume(tag_options, :responsive_placeholder)
     client_hints = Cloudinary::Utils.config_option_consume(tag_options, :client_hints)
@@ -51,15 +87,21 @@ module CloudinaryHelper
     hidpi = tag_options.delete(:hidpi)
     responsive = tag_options.delete(:responsive)
     if !client_hints && (hidpi || responsive)
-      tag_options["data-src"] = source
-      source = nil
+      tag_options["data-src"] = src
+      src = nil
       extra_class = responsive ? "cld-responsive" : "cld-hidpi"
       tag_options[:class] = [tag_options[:class], extra_class].compact.join(" ")
       responsive_placeholder = CL_BLANK if responsive_placeholder == "blank"
       tag_options[:src] = responsive_placeholder
     end
+    responsive_attrs = generate_image_responsive_attributes(source, attributes, srcset_param, options)
+    unless  responsive_attrs.empty?
+      tag_options.delete(:width)
+      tag_options.delete(:height)
+      tag_options.merge! responsive_attrs
+    end
     if block_given?
-      yield(source,tag_options)
+      yield(src,tag_options)
     else
       tag('div', tag_options)
     end
@@ -244,7 +286,7 @@ module CloudinaryHelper
     Cloudinary::Utils.private_download_url(public_id, format, options)
   end
 
-  # Helper method that uses the deprecated ZIP download API. 
+  # Helper method that uses the deprecated ZIP download API.
   # Replaced by cl_download_zip_url that uses the more advanced and robust archive generation and download API
   # @deprecated
   def cl_zip_download_url(tag, options = {})
@@ -254,7 +296,7 @@ module CloudinaryHelper
   # @see {Cloudinary::Utils.download_archive_url}
   def cl_download_archive_url(options = {})
     Cloudinary::Utils.download_archive_url(options)
-  end  
+  end
 
   # @see {Cloudinary::Utils.download_zip_url}
   def cl_download_zip_url(options = {})
@@ -276,11 +318,12 @@ module CloudinaryHelper
       if Cloudinary.config.enhance_image_tag
         alias_method :image_tag, :image_tag_with_cloudinary
         alias_method :image_path, :image_path_with_cloudinary
-      end    
+      end
     end
   end
 
   private
+
   def cloudinary_url_internal(source, options = {})
     options[:ssl_detected] = request.ssl? if defined?(request) && request && request.respond_to?(:ssl?)
     if defined?(CarrierWave::Uploader::Base) && source.is_a?(CarrierWave::Uploader::Base)
@@ -376,3 +419,30 @@ rescue LoadError
   # no sass support. Ignore.
 end
 
+begin
+  require 'sassc'
+  require 'sassc/script/functions'
+  module SassC::Script::Functions
+    # Helper method for generating cloudinary_url in scss files.
+    #
+    # As opposed to sass(deprecated), optional named arguments are not supported, use hash map instead.
+    #
+    # Example:
+    #   Sass: cloudinary-url("sample", $quality: "auto", $fetch_format: "auto");
+    #  becomes
+    #   SassC: cloudinary-url("sample", ("quality": "auto", "fetch_format": "auto"));
+    #
+    # @param [::SassC::Script::Value::String] public_id The public ID of the resource
+    # @param [::SassC::Script::Value::Map] sass_options Additional options
+    #
+    # @return [::SassC::Script::Value::String]
+    def cloudinary_url(public_id, sass_options = {})
+      options = {}
+      sass_options.to_h.each { |k, v| options[k.value.to_sym] = v.value }
+      url = Cloudinary::Utils.cloudinary_url(public_id.value, {:type => :asset}.merge(options))
+      ::SassC::Script::Value::String.new("url(#{url})")
+    end
+  end
+rescue LoadError
+  # no sassc support. Ignore.
+end

data/lib/cloudinary/migrator.rb

@@ -299,7 +299,9 @@ class Cloudinary::Migrator
   
   def debug(message)
     if @debug
-      $stderr.print "#{Time.now} Cloudinary::Migrator #{message}\n"
+      mutex.synchronize{
+        $stderr.print "#{Time.now} Cloudinary::Migrator #{message}\n"
+      }
     end
   end
 

data/lib/cloudinary/railtie.rb

@@ -1,8 +1,12 @@
 class Cloudinary::Railtie < Rails::Railtie
   rake_tasks do
-    Dir[File.join(File.dirname(__FILE__),'../tasks/*.rake')].each { |f| load f }
-  end  
+    Dir[File.join(File.dirname(__FILE__),'../tasks/**/*.rake')].each { |f| load f }
+  end
   config.after_initialize do |app|
     ActionView::Base.send :include, CloudinaryHelper
   end
-end
+
+  ActiveSupport.on_load(:action_controller_base) do
+    ActionController::Base.send :include, Cloudinary::CloudinaryController
+  end
+end

data/lib/cloudinary/responsive.rb

@@ -0,0 +1,111 @@
+module Responsive
+  # Calculate breakpoints for the given configuration
+  # @private
+  def generate_breakpoints(srcset)
+    return srcset[:breakpoints] if srcset[:breakpoints].is_a? Array
+    min_width, max_width, max_images = [:min_width, :max_width, :max_images].map {|k| srcset[k]}
+    unless [min_width, max_width, max_images].all? {|a| a.is_a? Numeric}
+      throw 'Either (min_width, max_width, max_images) or breakpoints must be provided to the image srcset attribute'
+    end
+    if min_width > max_width
+      throw 'min_width must be less than max_width'
+    end
+
+    if max_images <= 0
+      throw 'max_images must be a positive integer'
+    elsif max_images === 1
+      min_width = max_width
+    end
+    step_size = ((max_width - min_width).to_f / [max_images - 1, 1].max).ceil
+    current = min_width
+    breakpoints = []
+    while current < max_width do
+      breakpoints.push(current)
+      current += step_size
+    end
+    breakpoints.push(max_width)
+  end
+
+  # Generate the srcset and sizes attributes
+  # @private
+  def generate_image_responsive_attributes(public_id, attributes = {}, srcset_data = {}, options = {})
+    # Create both srcset and sizes here to avoid fetching breakpoints twice
+
+    responsive_attributes = {}
+    generate_srcset = !attributes[:srcset]
+
+    if srcset_data.empty?
+      return responsive_attributes
+    elsif srcset_data.is_a? String
+      responsive_attributes[:srcset] = srcset_data
+      return responsive_attributes
+    end
+
+    generate_sizes = !attributes[:sizes] && srcset_data[:sizes]
+
+    if generate_srcset || generate_sizes
+      breakpoints = get_or_generate_breakpoints(public_id, srcset_data, options)
+
+      if generate_srcset
+        transformation = srcset_data[:transformation]
+        srcset_attr = generate_srcset_attribute(public_id, breakpoints, transformation, options)
+        responsive_attributes[:srcset] = srcset_attr unless srcset_attr.empty?
+      end
+
+      if generate_sizes
+        sizes_attr = generate_sizes_attribute(breakpoints)
+        responsive_attributes[:sizes] = sizes_attr unless sizes_attr.empty?
+      end
+    end
+
+    responsive_attributes
+  end
+
+  # If cache is enabled, get the breakpoints from the cache. If the values were not found in the cache,
+  # or cache is not enabled, generate the values.
+  # @private
+  def get_or_generate_breakpoints(public_id, srcset, options)
+    if srcset[:use_cache]
+      Cloudinary::Cache.get(public_id, options) || []
+    else
+      generate_breakpoints(srcset)
+    end
+  end
+
+  # Generate a resource URL scaled to the given width
+  # @private
+  def generate_scaled_url(public_id, width, transformation={}, options={})
+    config_params = Cloudinary::Utils.extract_config_params(options)
+    transformation ||= options
+    config_params[:raw_transformation] = Cloudinary::Utils.generate_transformation_string(
+        [transformation.clone, {:crop => 'scale', :width => width}].reject(&:blank?))
+    config_params.delete :width
+    config_params.delete :height
+    Cloudinary::Utils.cloudinary_url public_id, config_params
+  end
+
+  # Generate srcset attribute value of the HTML img tag
+  # @private
+  def generate_srcset_attribute(public_id, breakpoints, transformation={}, options={})
+    options = options.clone
+    Cloudinary::Utils.patch_fetch_format(options)
+    breakpoints.map{|width| "#{generate_scaled_url(public_id, width, transformation, options)} #{width}w"}.join(', ').html_safe
+  end
+
+  # Generate media attribute value of the HTML img tag
+  # @private
+  def generate_media_attribute(options)
+    options ||= {}
+    [:min_width, :max_width]
+      .select {|name| options[name]}
+      .map {|name| "(#{name.to_s.tr('_', '-')}: #{options[name]}px)"}
+      .join(' and ').html_safe
+  end
+
+
+  # Generate the sizes attribute
+  # @private
+  def generate_sizes_attribute(breakpoints)
+    breakpoints.map{|width| "(max-width: #{width}px) #{width}px"}.join(', ')
+  end
+end

data/lib/cloudinary/uploader.rb

@@ -1,11 +1,11 @@
 # Copyright Cloudinary
 require 'rest_client'
 require 'json'
+require 'cloudinary/cache'
 
 class Cloudinary::Uploader
 
-  REMOTE_URL_REGEX = %r(^ftp:|^https?:|^s3:|^data:[^;]*;base64,([a-zA-Z0-9\/+\n=]+)$)
-
+  REMOTE_URL_REGEX = Cloudinary::Utils::REMOTE_URL_REGEX
   # @deprecated use {Cloudinary::Utils.build_eager} instead
   def self.build_eager(eager)
     Cloudinary::Utils.build_eager(eager)
@@ -27,6 +27,7 @@ class Cloudinary::Uploader
       :backup                    => Cloudinary::Utils.as_safe_bool(options[:backup]),
       :callback                  => options[:callback],
       :categorization            => options[:categorization],
+      :cinemagraph_analysis      => Cloudinary::Utils.as_safe_bool(options[:cinemagraph_analysis]),
       :colors                    => Cloudinary::Utils.as_safe_bool(options[:colors]),
       :context                   => Cloudinary::Utils.encode_context(options[:context]),
       :custom_coordinates        => Cloudinary::Utils.encode_double_array(options[:custom_coordinates]),
@@ -36,10 +37,12 @@ class Cloudinary::Uploader
       :eager_async               => Cloudinary::Utils.as_safe_bool(options[:eager_async]),
       :eager_notification_url    => options[:eager_notification_url],
       :exif                      => Cloudinary::Utils.as_safe_bool(options[:exif]),
+      :eval                      => options[:eval],
       :face_coordinates          => Cloudinary::Utils.encode_double_array(options[:face_coordinates]),
       :faces                     => Cloudinary::Utils.as_safe_bool(options[:faces]),
       :folder                    => options[:folder],
       :format                    => options[:format],
+      :filename_override         => options[:filename_override],
       :headers                   => build_custom_headers(options[:headers]),
       :image_metadata            => Cloudinary::Utils.as_safe_bool(options[:image_metadata]),
       :invalidate                => Cloudinary::Utils.as_safe_bool(options[:invalidate]),
@@ -50,6 +53,8 @@ class Cloudinary::Uploader
       :phash                     => Cloudinary::Utils.as_safe_bool(options[:phash]),
       :proxy                     => options[:proxy],
       :public_id                 => options[:public_id],
+      :quality_analysis          => Cloudinary::Utils.as_safe_bool(options[:quality_analysis]),
+      :quality_override          => options[:quality_override],
       :raw_convert               => options[:raw_convert],
       :responsive_breakpoints    => Cloudinary::Utils.generate_responsive_breakpoints_string(options[:responsive_breakpoints]),
       :return_delete_token       => Cloudinary::Utils.as_safe_bool(options[:return_delete_token]),
@@ -61,6 +66,8 @@ class Cloudinary::Uploader
       :unique_filename           => Cloudinary::Utils.as_safe_bool(options[:unique_filename]),
       :upload_preset             => options[:upload_preset],
       :use_filename              => Cloudinary::Utils.as_safe_bool(options[:use_filename]),
+      :accessibility_analysis    => Cloudinary::Utils.as_safe_bool(options[:accessibility_analysis]),
+      :metadata                  => Cloudinary::Utils.encode_context(options[:metadata])
     }
     params
   end
@@ -74,7 +81,10 @@ 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.match(REMOTE_URL_REGEX)
+      elsif file.is_a?(StringIO)
+        file.rewind
+        params[:file] = Cloudinary::Blob.new(file.read, options)
+      elsif file.respond_to?(:read) || Cloudinary::Utils.is_remote?(file)
         params[:file] = file
       else
         params[:file] = File.open(file, "rb")
@@ -92,7 +102,7 @@ class Cloudinary::Uploader
       public_id = public_id_or_options
       options   = old_options
     end
-    if file.match(REMOTE_URL_REGEX)
+    if Cloudinary::Utils.is_remote?(file)
       return upload(file, options.merge(:public_id => public_id))
     elsif file.is_a?(Pathname) || !file.respond_to?(:read)
       filename = file
@@ -100,6 +110,7 @@ class Cloudinary::Uploader
     else
       filename = "cloudinaryfile"
     end
+    unique_upload_id = Cloudinary::Utils.random_public_id
     upload     = nil
     index      = 0
     chunk_size = options[:chunk_size] || 20_000_000
@@ -107,8 +118,7 @@ class Cloudinary::Uploader
       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"]
+      upload      = upload_large_part(Cloudinary::Blob.new(buffer, :original_filename => filename), options.merge(:public_id => public_id, :unique_upload_id => unique_upload_id, :content_range => range))
       index       += 1
     end
     upload
@@ -245,7 +255,7 @@ class Cloudinary::Uploader
     end
   end
 
-  # options may include 'exclusive' (boolean) which causes clearing this tag from all other resources 
+  # options may include 'exclusive' (boolean) which causes clearing this tag from all other resources
   def self.add_tag(tag, public_ids = [], options = {})
     exclusive = options.delete(:exclusive)
     command   = exclusive ? "set_exclusive" : "add"
@@ -264,6 +274,29 @@ class Cloudinary::Uploader
     return self.call_tags_api(nil, "remove_all", public_ids, options)
   end
 
+  # Populates metadata fields with the given values. Existing values will be overwritten.
+  #
+  # Any metadata-value pairs given are merged with any existing metadata-value pairs
+  # (an empty value for an existing metadata field clears the value).
+  #
+  # @param [Hash] metadata    A list of custom metadata fields (by external_id) and the values to assign to each of them.
+  # @param [Array] public_ids An array of Public IDs of assets uploaded to Cloudinary.
+  # @param [Hash] options
+  # @option options [String] :resource_type The type of file. Default: image. Valid values: image, raw, video.
+  # @option options [String] :type          The storage type. Default: upload. Valid values: upload, private, authenticated
+  # @return mixed a list of public IDs that were updated
+  # @raise [Cloudinary::Api:Error]
+  def self.update_metadata(metadata, public_ids, options = {})
+    self.call_api("metadata", options) do
+      {
+        timestamp: (options[:timestamp] || Time.now.to_i),
+        type: options[:type],
+        public_ids: Cloudinary::Utils.build_array(public_ids),
+        metadata: Cloudinary::Utils.encode_context(metadata)
+      }
+    end
+  end
+
   private
 
   def self.call_tags_api(tag, command, public_ids = [], options = {})
@@ -292,7 +325,7 @@ class Cloudinary::Uploader
     return call_api("context", options) do
       {
         :timestamp  => (options[:timestamp] || Time.now.to_i),
-        :context    => Cloudinary::Utils.encode_hash(context),
+        :context    => Cloudinary::Utils.encode_context(context),
         :public_ids => Cloudinary::Utils.build_array(public_ids),
         :command    => command,
         :type       => options[:type]
@@ -303,25 +336,29 @@ class Cloudinary::Uploader
   def self.call_api(action, options)
     options      = options.clone
     return_error = options.delete(:return_error)
+    use_cache = options[:use_cache] || Cloudinary.config.use_cache
 
     params, non_signable = yield
     non_signable         ||= []
 
     unless options[:unsigned]
-      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[:signature] = Cloudinary::Utils.api_sign_request(params.reject { |k, v| non_signable.include?(k) }, api_secret)
-      params[:api_key]   = api_key
+      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")
+      signature_algorithm = options[:signature_algorithm]
+      params[:signature]  = Cloudinary::Utils.api_sign_request(params.reject { |k, v| non_signable.include?(k) }, api_secret, signature_algorithm)
+      params[:api_key]    = api_key
     end
-    timeout = options[:timeout] || Cloudinary.config.timeout || 60
+    proxy   = options[:api_proxy] || Cloudinary.config.api_proxy
+    timeout = options.fetch(:timeout) { Cloudinary.config.to_h.fetch(:timeout, 60) }
 
     result = nil
 
     api_url                  = Cloudinary::Utils.cloudinary_api_url(action, options)
     headers                  = { "User-Agent" => Cloudinary::USER_AGENT }
     headers['Content-Range'] = options[:content_range] if options[:content_range]
+    headers['X-Unique-Upload-Id'] = options[:unique_upload_id] if options[:unique_upload_id]
     headers.merge!(options[:extra_headers]) if options[:extra_headers]
-    RestClient::Request.execute(:method => :post, :url => api_url, :payload => params.reject { |k, v| v.nil? || v=="" }, :timeout => timeout, :headers => headers) do
+    RestClient::Request.execute(:method => :post, :url => api_url, :payload => params.reject { |k, v| v.nil? || v=="" }, :timeout => timeout, :headers => headers, :proxy => proxy) do
     |response, request, tmpresult|
       raise CloudinaryException, "Server returned unexpected status code - #{response.code} - #{response.body}" unless [200, 400, 401, 403, 404, 500].include?(response.code)
       begin
@@ -338,11 +375,26 @@ class Cloudinary::Uploader
         end
       end
     end
-
+    if use_cache && !result.nil?
+      cache_results(result)
+    end
     result
   end
 
   def self.build_custom_headers(headers)
     Array(headers).map { |*a| a.join(": ") }.join("\n")
   end
+
+  def self.cache_results(result)
+      if result["responsive_breakpoints"]
+        result["responsive_breakpoints"].each do |bp|
+          Cloudinary::Cache.set(
+            result["public_id"],
+            {type: result["type"], resource_type: result["resource_type"], raw_transformation: bp["transformation"]},
+            bp["breakpoints"].map{|o| o['width']}
+          )
+          end
+      end
+
+      end
 end