cloudinary 1.17.0 → 1.20.0

data/lib/cloudinary/config.rb

@@ -0,0 +1,43 @@
+module Cloudinary
+  module Config
+    include BaseConfig
+
+    ENV_URL = "CLOUDINARY_URL"
+    SCHEME = "cloudinary"
+
+    def load_config_from_env
+      if ENV["CLOUDINARY_CLOUD_NAME"]
+        config_keys = ENV.keys.select! { |key| key.start_with? "CLOUDINARY_" }
+        config_keys -= ["CLOUDINARY_URL"] # ignore it when explicit options are passed
+        config_keys.each do |full_key|
+          conf_key = full_key["CLOUDINARY_".length..-1].downcase # convert "CLOUDINARY_CONFIG_NAME" to "config_name"
+          conf_val = ENV[full_key]
+          conf_val = conf_val == 'true' if %w[true false].include?(conf_val) # cast relevant boolean values
+          update(conf_key => conf_val)
+        end
+      elsif ENV[ENV_URL]
+        load_from_url(ENV[ENV_URL])
+      end
+    end
+
+    private
+
+    def env_url
+      ENV_URL
+    end
+
+    def expected_scheme
+      SCHEME
+    end
+
+    def config_from_parsed_url(parsed_url)
+      {
+        "cloud_name"          => parsed_url.host,
+        "api_key"             => parsed_url.user,
+        "api_secret"          => parsed_url.password,
+        "private_cdn"         => !parsed_url.path.blank?,
+        "secure_distribution" => parsed_url.path[1..-1]
+      }
+    end
+  end
+end

data/lib/cloudinary/helper.rb

@@ -438,7 +438,7 @@ begin
     # @return [::SassC::Script::Value::String]
     def cloudinary_url(public_id, sass_options = {})
       options = {}
-      sass_options.to_h.each { |k, v| options[k.value] = v.value }
+      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

data/lib/cloudinary/uploader.rb

@@ -42,6 +42,7 @@ class Cloudinary::Uploader
       :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]),
@@ -65,7 +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])
+      :accessibility_analysis    => Cloudinary::Utils.as_safe_bool(options[:accessibility_analysis]),
+      :metadata                  => Cloudinary::Utils.encode_context(options[:metadata])
     }
     params
   end
@@ -272,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 = {})
@@ -317,11 +342,13 @@ class Cloudinary::Uploader
     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
+    proxy   = options[:api_proxy] || Cloudinary.config.api_proxy
     timeout = options.fetch(:timeout) { Cloudinary.config.to_h.fetch(:timeout, 60) }
 
     result = nil
@@ -331,7 +358,7 @@ class Cloudinary::Uploader
     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

data/lib/cloudinary/utils.rb

@@ -32,19 +32,34 @@ class Cloudinary::Utils
 
   PREDEFINED_VARS = {
     "aspect_ratio"         => "ar",
+    "aspectRatio"          => "ar",
     "current_page"         => "cp",
+    "currentPage"          => "cp",
     "face_count"           => "fc",
+    "faceCount"            => "fc",
     "height"               => "h",
     "initial_aspect_ratio" => "iar",
+    "initialAspectRatio"   => "iar",
+    "trimmed_aspect_ratio" => "tar",
+    "trimmedAspectRatio"   => "tar",
     "initial_height"       => "ih",
+    "initialHeight"        => "ih",
     "initial_width"        => "iw",
+    "initialWidth"         => "iw",
     "page_count"           => "pc",
+    "pageCount"            => "pc",
     "page_x"               => "px",
+    "pageX"                => "px",
     "page_y"               => "py",
+    "pageY"                => "py",
     "tags"                 => "tags",
     "initial_duration"     => "idu",
+    "initialDuration"      => "idu",
     "duration"             => "du",
-    "width"                => "w"
+    "width"                => "w",
+    "illustration_score"   => "ils",
+    "illustrationScore"    => "ils",
+    "context"              => "ctx"
   }
 
   SIMPLE_TRANSFORMATION_PARAMS = {
@@ -144,6 +159,16 @@ class Cloudinary::Utils
   LONG_URL_SIGNATURE_LENGTH = 32
   SHORT_URL_SIGNATURE_LENGTH = 8
 
+  UPLOAD_PREFIX = 'https://api.cloudinary.com'
+
+  ALGO_SHA1 = :sha1
+  ALGO_SHA256 = :sha256
+
+  ALGORITHM_SIGNATURE = {
+    ALGO_SHA1 => Digest::SHA1,
+    ALGO_SHA256 => Digest::SHA256,
+  }
+
   def self.extract_config_params(options)
       options.select{|k,v| URL_KEYS.include?(k)}
   end
@@ -309,16 +334,16 @@ class Cloudinary::Utils
     "if_" + normalize_expression(if_value) unless if_value.to_s.empty?
   end
 
-  EXP_REGEXP = Regexp.new('(?<!\$)('+PREDEFINED_VARS.keys.join("|")+')'+'|('+CONDITIONAL_OPERATORS.keys.reverse.map { |k| Regexp.escape(k) }.join('|')+')(?=[ _])')
+  EXP_REGEXP = Regexp.new('(\$_*[^_ ]+)|(?<!\$)('+PREDEFINED_VARS.keys.join("|")+')'+'|('+CONDITIONAL_OPERATORS.keys.reverse.map { |k| Regexp.escape(k) }.join('|')+')(?=[ _])')
   EXP_REPLACEMENT = PREDEFINED_VARS.merge(CONDITIONAL_OPERATORS)
 
   def self.normalize_expression(expression)
     if expression.nil?
-      ''
+      nil
     elsif expression.is_a?( String) && expression =~ /^!.+!$/ # quoted string
       expression
     else
-      expression.to_s.gsub(EXP_REGEXP,EXP_REPLACEMENT).gsub(/[ _]+/, "_")
+      expression.to_s.gsub(EXP_REGEXP) { |match| EXP_REPLACEMENT[match] || match }.gsub(/[ _]+/, "_")
     end
   end
 
@@ -433,9 +458,9 @@ class Cloudinary::Utils
     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)
+  def self.api_sign_request(params_to_sign, api_secret, signature_algorithm = nil)
     to_sign = api_string_to_sign(params_to_sign)
-    Digest::SHA1.hexdigest("#{to_sign}#{api_secret}")
+    hash("#{to_sign}#{api_secret}", signature_algorithm, :hexdigest)
   end
 
   # Returns a JSON array as String.
@@ -501,6 +526,7 @@ class Cloudinary::Utils
     use_root_path = config_option_consume(options, :use_root_path)
     auth_token = config_option_consume(options, :auth_token)
     long_url_signature = config_option_consume(options, :long_url_signature)
+    signature_algorithm = config_option_consume(options, :signature_algorithm)
     unless auth_token == false
       auth_token = Cloudinary::AuthToken.merge_auth_token(Cloudinary.config.auth_token, auth_token)
     end
@@ -545,7 +571,10 @@ class Cloudinary::Utils
       raise(CloudinaryException, "Must supply api_secret") if (secret.nil? || secret.empty?)
       to_sign = [transformation, sign_version && version, source_to_sign].reject(&:blank?).join("/")
       to_sign = fully_unescape(to_sign)
-      signature = compute_signature(to_sign, secret, long_url_signature)
+      signature_algorithm = long_url_signature ? ALGO_SHA256 : signature_algorithm
+      hash = hash("#{to_sign}#{secret}", signature_algorithm)
+      signature = Base64.urlsafe_encode64(hash)
+      signature = "s--#{signature[0, long_url_signature ? LONG_URL_SIGNATURE_LENGTH : SHORT_URL_SIGNATURE_LENGTH ]}--"
     end
 
     prefix = unsigned_download_url_prefix(source, cloud_name, private_cdn, cdn_subdomain, secure_cdn_subdomain, cname, secure, secure_distribution)
@@ -661,18 +690,31 @@ class Cloudinary::Utils
     prefix
   end
 
+  # Creates a base URL for the cloudinary api
+  #
+  # @param [Object] path  Resource name
+  # @param [Hash] options Additional options
+  #
+  # @return [String]
+  def self.base_api_url(path, options = {})
+    cloudinary = options[:upload_prefix] || Cloudinary.config.upload_prefix || UPLOAD_PREFIX
+    cloud_name = options[:cloud_name] || Cloudinary.config.cloud_name || raise(CloudinaryException, 'Must supply cloud_name')
+
+    [cloudinary, 'v1_1', cloud_name, path].join('/')
+  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("/")
+    resource_type = options[:resource_type] || 'image'
+
+    base_api_url([resource_type, action], options)
   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")
+    signature_algorithm = options[:signature_algorithm]
     params = params.reject{|k, v| self.safe_blank?(v)}
-    params[:signature] = Cloudinary::Utils.api_sign_request(params, api_secret)
+    params[:signature] = api_sign_request(params, api_secret, signature_algorithm)
     params[:api_key] = api_key
     params
   end
@@ -736,6 +778,18 @@ class Cloudinary::Utils
     download_archive_url(options.merge(:target_format => "zip"))
   end
 
+  # Creates and returns a URL that when invoked creates an archive of a folder.
+  #
+  # @param [Object] folder_path Full path (from the root) of the folder to download.
+  # @param [Hash] options       Additional options.
+  #
+  # @return [String]
+  def self.download_folder(folder_path, options = {})
+    resource_type = options[:resource_type] || "all"
+
+    download_archive_url(options.merge(:resource_type => resource_type, :prefixes => folder_path))
+  end
+
   def self.signed_download_url(public_id, options = {})
     aws_private_key_path = options[:aws_private_key_path] || Cloudinary.config.aws_private_key_path
     if aws_private_key_path
@@ -1137,23 +1191,51 @@ class Cloudinary::Utils
     REMOTE_URL_REGEX === url
   end
 
-  # Computes a short or long signature based on a message and secret
-  # @param [String]  message The string to sign
-  # @param [String]  secret A secret that will be added to the message when signing
-  # @param [Boolean] long_signature Whether to create a short or long signature
-  # @return [String] Properly formatted signature
-  def self.compute_signature(message, secret, long_url_signature)
-    combined_message_secret = message + secret
+  # The returned url should allow downloading the backedup asset based on the version and asset id
+  #
+  # asset and version id are returned with resource(<PUBLIC_ID1>, { versions: true })
+  #
+  # @param [String] asset_id   Asset identifier
+  # @param [String] version_id Specific version of asset to download
+  # @param [Hash] options      Additional options
+  #
+  # @return [String] An url for downloading a file
+  def self.download_backedup_asset(asset_id, version_id, options = {})
+    params = Cloudinary::Utils.sign_request({
+      :timestamp => (options[:timestamp] || Time.now.to_i),
+      :asset_id => asset_id,
+      :version_id => version_id
+    }, options)
+
+    "#{Cloudinary::Utils.base_api_url("download_backup", options)}?#{Cloudinary::Utils.hash_query_params((params))}"
+  end
 
-    algo, signature_length =
-      if long_url_signature
-        [Digest::SHA256, LONG_URL_SIGNATURE_LENGTH]
-      else
-        [Digest::SHA1, SHORT_URL_SIGNATURE_LENGTH]
-      end
+  # Format date in a format accepted by the usage API (e.g., 31-12-2020) if
+  # passed value is of type Date, otherwise return the string representation of
+  # the input.
+  #
+  # @param [Date|Object] date
+  # @return [String]
+  def self.to_usage_api_date_format(date)
+    if date.is_a?(Date)
+      date.strftime('%d-%m-%Y')
+    else
+      date.to_s
+    end
+  end
 
-    "s--#{Base64.urlsafe_encode64(algo.digest(combined_message_secret))[0, signature_length]}--"
+  # Computes hash from input string using specified algorithm.
+  #
+  # @param [String] input                   String which to compute hash from
+  # @param [String|nil] signature_algorithm Algorithm to use for computing hash
+  # @param [Symbol] hash_method             Hash method applied to a signature algorithm (:digest or :hexdigest)
+  #
+  # @return [String] Computed hash value
+  def self.hash(input, signature_algorithm = nil, hash_method = :digest)
+    signature_algorithm ||= Cloudinary.config.signature_algorithm || ALGO_SHA1
+    algorithm = ALGORITHM_SIGNATURE[signature_algorithm] || raise("Unsupported algorithm '#{signature_algorithm}'")
+    algorithm.public_send(hash_method, input)
   end
 
-  private_class_method :compute_signature
+  private_class_method :hash
 end

data/lib/cloudinary/version.rb

@@ -1,4 +1,4 @@
 # Copyright Cloudinary
 module Cloudinary
-  VERSION = "1.17.0"
+  VERSION = "1.20.0"
 end

data/lib/cloudinary/video_helper.rb

@@ -3,12 +3,33 @@ module CloudinaryHelper
   DEFAULT_POSTER_OPTIONS = { :format => 'jpg', :resource_type => 'video' }
   DEFAULT_SOURCE_TYPES   = %w(webm mp4 ogv)
   DEFAULT_VIDEO_OPTIONS  = { :resource_type => 'video' }
+  DEFAULT_SOURCES        = [
+    {
+      :type            => "mp4",
+      :codecs          => "hev1",
+      :transformations => { :video_codec => "h265" }
+    },
+    {
+      :type            => "webm",
+      :codecs          => "vp9",
+      :transformations => { :video_codec => "vp9" }
+    },
+    {
+      :type            => "mp4",
+      :transformations => { :video_codec => "auto" }
+    },
+    {
+      :type            => "webm",
+      :transformations => { :video_codec => "auto" }
+    }
+  ]
 
   # Creates an HTML video tag for the provided +source+
   #
   # ==== Options
   # * <tt>:source_types</tt> - Specify which source type the tag should include. defaults to webm, mp4 and ogv.
   # * <tt>:source_transformation</tt> - specific transformations to use for a specific source type.
+  # * <tt>:sources</tt> - list of sources (overrides :source_types when present)
   # * <tt>:poster</tt> - override default thumbnail:
   #   * url: provide an ad hoc url
   #   * options: with specific poster transformations and/or Cloudinary +:public_id+
@@ -20,6 +41,17 @@ module CloudinaryHelper
   #   cl_video_tag("mymovie.webm", :source_types => [:webm, :mp4], :poster => {:effect => 'sepia'}) do
   #     content_tag( :span, "Cannot present video!")
   #   end
+  #   cl_video_tag("mymovie", :sources => [
+  #     {
+  #       :type => "mp4",
+  #       :codecs => "hev1",
+  #       :transformations => { :video_codec => "h265" }
+  #     },
+  #     {
+  #       :type => "webm",
+  #       :transformations => { :video_codec => "auto" }
+  #     }
+  #   ])
   def cl_video_tag(source, options = {}, &block)
     source = strip_known_ext(source)
     video_attributes = [:autoplay,:controls,:loop,:muted,:poster, :preload]
@@ -48,30 +80,12 @@ module CloudinaryHelper
       video_options[:poster] = cl_video_thumbnail_path(source, options)
     end
 
-    source_transformation = options.delete(:source_transformation) || {}
-    source_types = Array(options.delete(:source_types))
-    fallback     = (capture(&block) if block_given?) || options.delete(:fallback_content)
+    fallback = (capture(&block) if block_given?) || options.delete(:fallback_content)
 
-    if source_types.size > 1
-      cloudinary_tag(source, options) do |_source, tag_options|
-        content_tag('video', tag_options.merge(video_options)) do
-          source_tags = source_types.map do |type|
-            transformation = source_transformation[type.to_sym] || {}
-            cloudinary_tag("#{source}.#{type}", options.merge(transformation)) do |url, _tag_options|
-              mime_type = "video/#{(type == 'ogv' ? 'ogg' : type)}"
-              tag("source", :src => url, :type => mime_type)
-            end
-          end
-          source_tags.push(fallback.html_safe) unless fallback.blank?
-          safe_join(source_tags)
-        end
-      end
+    if options[:sources]
+      video_tag_from_sources(source, options, video_options, fallback)
     else
-      transformation      = source_transformation[source_types.first.to_sym] || {}
-      video_options[:src] = cl_video_path("#{source}.#{source_types.first.to_sym}", transformation.merge(options))
-      cloudinary_tag(source, options) do |_source, tag_options|
-        content_tag('video', fallback, tag_options.merge(video_options))
-      end
+      video_tag_from_source_types(source, options, video_options, fallback)
     end
   end
 
@@ -96,6 +110,66 @@ module CloudinaryHelper
     name.sub(/\.(#{DEFAULT_SOURCE_TYPES.join("|")})$/, '')
   end
 
+  private
+
+  def video_tag_from_source_types(source_name, options, video_options, fallback)
+    source_transformation = options.delete(:source_transformation) || {}
+    source_types = Array(options.delete(:source_types))
+
+    if source_types.size > 1
+      sources = source_types.map do |type|
+        {
+          :type => type,
+          :transformations => source_transformation[type.to_sym] || {}
+        }
+      end
+
+      generate_tag_from_sources(:source_name => source_name,
+                                :sources => sources,
+                                :options => options,
+                                :video_options => video_options,
+                                :fallback => fallback)
+    else
+      transformation      = source_transformation[source_types.first.to_sym] || {}
+      video_options[:src] = cl_video_path("#{source_name}.#{source_types.first.to_sym}", transformation.merge(options))
+      cloudinary_tag(source_name, options) do |_source, tag_options|
+        content_tag('video', fallback, tag_options.merge(video_options))
+      end
+    end
+  end
+
+  def video_tag_from_sources(source_name, options, video_options, fallback)
+    sources = options.delete(:sources)
+
+    generate_tag_from_sources(:source_name => source_name,
+                              :sources => sources,
+                              :options => options,
+                              :video_options => video_options,
+                              :fallback => fallback)
+  end
+
+  def generate_tag_from_sources(params)
+    source_name, sources, options, video_options, fallback = params.values_at(:source_name, :sources, :options, :video_options, :fallback)
+
+    cloudinary_tag(source_name, options) do |_source, tag_options|
+      content_tag('video', tag_options.merge(video_options)) do
+        source_tags = sources.map do |source|
+          type = source[:type]
+          transformation = source[:transformations] || {}
+          cloudinary_tag("#{source_name}.#{type}", options.merge(transformation)) do |url, _tag_options|
+            mime_type = "video/#{(type == 'ogv' ? 'ogg' : type)}"
+            if source[:codecs]
+              codecs = source[:codecs].is_a?(Array) ? source[:codecs].join(", ") : source[:codecs]
+              mime_type = "#{mime_type}; codecs=#{codecs}"
+            end
+            tag("source", :src => url, :type => mime_type)
+          end
+        end
+        source_tags.push(fallback.html_safe) unless fallback.blank?
+        safe_join(source_tags)
+      end
+    end
+  end
 end