cloudinary 1.29.0 → 2.3.0

data/lib/cloudinary/uploader.rb

@@ -1,83 +1,53 @@
 # Copyright Cloudinary
-require 'rest_client'
+require 'faraday'
 require 'json'
 require 'cloudinary/cache'
 
 class Cloudinary::Uploader
-
-  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)
-  end
-
-  # @private
-  def self.build_upload_params(options)
+  @adapter = nil
+  def self.build_upload_params(options, as_bool = false)
     #symbolize keys
     options = options.clone
     options.keys.each { |key| options[key.to_sym] = options.delete(key) if key.is_a?(String) }
 
     params = {
-      :access_control                       => Cloudinary::Utils.json_array_param(options[:access_control]),
-      :access_mode                          => options[:access_mode],
-      :allowed_formats                      => Cloudinary::Utils.build_array(options[:allowed_formats]).join(","),
-      :asset_folder                         => options[:asset_folder],
-      :async                                => Cloudinary::Utils.as_safe_bool(options[:async]),
-      :auto_tagging                         => options[:auto_tagging] && options[:auto_tagging].to_f,
-      :background_removal                   => options[:background_removal],
-      :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]),
-      :detection                            => options[:detection],
-      :discard_original_filename            => Cloudinary::Utils.as_safe_bool(options[:discard_original_filename]),
-      :display_name                         => options[:display_name],
-      :eager                                => Cloudinary::Utils.build_eager(options[:eager]),
-      :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],
-      :on_success                           => options[:on_success],
-      :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]),
-      :media_metadata                       => Cloudinary::Utils.as_safe_bool(options[:media_metadata]),
-      :invalidate                           => Cloudinary::Utils.as_safe_bool(options[:invalidate]),
-      :moderation                           => options[:moderation],
-      :notification_url                     => options[:notification_url],
-      :ocr                                  => options[:ocr],
-      :overwrite                            => Cloudinary::Utils.as_safe_bool(options[:overwrite]),
-      :phash                                => Cloudinary::Utils.as_safe_bool(options[:phash]),
-      :proxy                                => options[:proxy],
-      :public_id                            => options[:public_id],
-      :public_id_prefix                     => options[:public_id_prefix],
-      :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]),
-      :similarity_search                    => options[:similarity_search],
-      :visual_search                        => Cloudinary::Utils.as_safe_bool(options[:visual_search]),
-      :tags                                 => options[:tags] && Cloudinary::Utils.build_array(options[:tags]).join(","),
-      :timestamp                            => (options[:timestamp] || Time.now.to_i),
-      :transformation                       => Cloudinary::Utils.generate_transformation_string(options.clone),
-      :type                                 => options[:type],
-      :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]),
-      :use_filename_as_display_name         => Cloudinary::Utils.as_safe_bool(options[:use_filename_as_display_name]),
-      :use_asset_folder_as_public_id_prefix => Cloudinary::Utils.as_safe_bool(options[:use_asset_folder_as_public_id_prefix]),
-      :unique_display_name                  => Cloudinary::Utils.as_safe_bool(options[:unique_display_name]),
-      :accessibility_analysis               => Cloudinary::Utils.as_safe_bool(options[:accessibility_analysis]),
-      :metadata                             => Cloudinary::Utils.encode_context(options[:metadata])
+      :access_control         => Cloudinary::Utils.json_array_param(options[:access_control]),
+      :allowed_formats        => Cloudinary::Utils.build_array(options[:allowed_formats]).join(","),
+      :auto_tagging           => options[:auto_tagging] && options[:auto_tagging].to_f,
+      :context                => Cloudinary::Utils.encode_context(options[:context]),
+      :custom_coordinates     => Cloudinary::Utils.encode_double_array(options[:custom_coordinates]),
+      :eager                  => Cloudinary::Utils.build_eager(options[:eager]),
+      :face_coordinates       => Cloudinary::Utils.encode_double_array(options[:face_coordinates]),
+      :headers                => build_custom_headers(options[:headers]),
+      :responsive_breakpoints => Cloudinary::Utils.generate_responsive_breakpoints_string(options[:responsive_breakpoints]),
+      :tags                   => options[:tags] && Cloudinary::Utils.build_array(options[:tags]).join(","),
+      :timestamp              => (options[:timestamp] || Time.now.to_i),
+      :transformation         => Cloudinary::Utils.generate_transformation_string(options.clone),
+      :metadata               => Cloudinary::Utils.encode_context(options[:metadata])
     }
+
+    bool_params = [
+      :async, :backup, :cinemagraph_analysis, :colors, :discard_original_filename, :eager_async, :exif, :faces,
+      :image_metadata, :media_metadata, :invalidate, :overwrite, :phash, :quality_analysis, :return_delete_token,
+      :visual_search, :unique_filename, :use_filename, :use_filename_as_display_name,
+      :use_asset_folder_as_public_id_prefix, :unique_display_name, :accessibility_analysis
+    ]
+
+    string_params = [
+      :access_mode, :asset_folder, :background_removal, :callback, :categorization, :detection, :display_name,
+      :eager_notification_url, :eval, :on_success, :folder, :format, :filename_override, :moderation, :notification_url,
+      :ocr, :proxy, :public_id, :public_id_prefix, :quality_override, :raw_convert, :similarity_search, :type,
+      :upload_preset
+    ]
+
+    bool_params.each do |b|
+      params[b] =  as_bool ? Cloudinary::Utils.as_bool(options[b]): Cloudinary::Utils.as_safe_bool(options[b])
+    end
+
+    string_params.each do |s|
+      params[s] =  options[s]
+    end
+
     params
   end
 
@@ -394,29 +364,39 @@ class Cloudinary::Uploader
       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
-
-    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 => 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
-        result = Cloudinary::Utils.json_decode(response.body)
-      rescue => e
-        # Error is parsing json
-        raise CloudinaryException, "Error parsing server response (#{response.code}) - #{response.body}. Got - #{e}"
-      end
-      if result["error"]
-        if return_error
-          result["error"]["http_code"] = response.code
-        else
-          raise CloudinaryException, result["error"]["message"]
-        end
+
+    api_url   = Cloudinary::Utils.cloudinary_api_url(action, options)
+    api_proxy = options[:api_proxy] || Cloudinary.config.api_proxy
+    timeout   = options.fetch(:timeout) { Cloudinary.config.to_h.fetch(:timeout, 60) }
+
+    conn =  Faraday.new(url: api_url) do |faraday|
+      faraday.proxy = api_proxy if api_proxy
+      faraday.request :multipart, **options
+      faraday.request :url_encoded
+      faraday.adapter @adapter || Faraday.default_adapter
+    end
+
+    response = conn.send(:post) do |req|
+      req.headers = headers
+      req.body = params.reject { |_, v| v.nil? || v=="" }
+      req.options.timeout = timeout if timeout
+    end
+
+    raise CloudinaryException, "Server returned unexpected status code - #{response.status} - #{response.body}" unless [200, 400, 401, 403, 404, 500].include?(response.status)
+    begin
+      result = Cloudinary::Utils.json_decode(response.body)
+    rescue => e
+      # Error is parsing json
+      raise CloudinaryException, "Error parsing server response (#{response.status}) - #{response.body}. Got - #{e}"
+    end
+    if result["error"]
+      if return_error
+        result["error"]["http_code"] = response.status
+      else
+        raise CloudinaryException, result["error"]["message"]
       end
     end
+
     if use_cache && !result.nil?
       cache_results(result)
     end

data/lib/cloudinary/utils.rb

@@ -4,15 +4,14 @@
 require 'digest/sha1'
 require 'zlib'
 require 'uri'
-require 'aws_cf_signer'
 require 'json'
 require 'cgi'
+require 'faraday'
+require 'faraday/multipart'
 require 'cloudinary/auth_token'
 require 'cloudinary/responsive'
 
 class Cloudinary::Utils
-  # @deprecated Use Cloudinary::SHARED_CDN
-  SHARED_CDN = Cloudinary::SHARED_CDN
   MODE_DOWNLOAD = "download"
   DEFAULT_RESPONSIVE_WIDTH_TRANSFORMATION = {:width => :auto, :crop => :limit}
   CONDITIONAL_OPERATORS = {
@@ -98,7 +97,6 @@ class Cloudinary::Utils
       secure_distribution
       shorten
       sign_url
-      ssl_detected
       type
       url_suffix
       use_root_path
@@ -155,7 +153,7 @@ class Cloudinary::Utils
       zoom
   ].map(&:to_sym)
 
-  REMOTE_URL_REGEX = %r(^ftp:|^https?:|^s3:|^gs:|^data:([\w-]+\/[\w-]+(\+[\w-]+)?)?(;[\w-]+=[\w-]+)*;base64,([a-zA-Z0-9\/+\n=]+)$)
+  REMOTE_URL_REGEX = %r(^ftp:|^https?:|^s3:|^gs:|^data:([\w-]+\/[\w-]+(\.[\w-]+)*(\+[\w-]+)?)?(;[\w-]+=[\w-]+)*;base64,([a-zA-Z0-9\/+\n=]+)$)
 
   LONG_URL_SIGNATURE_LENGTH = 32
   SHORT_URL_SIGNATURE_LENGTH = 8
@@ -513,7 +511,7 @@ class Cloudinary::Utils
   end
 
   # Warning: options are being destructively updated!
-  def self.unsigned_download_url(source, options = {})
+  def self.cloudinary_url(source, options = {})
 
     patch_fetch_format(options)
     type = options.delete(:type)
@@ -530,7 +528,6 @@ class Cloudinary::Utils
 
     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)
     auth_token = config_option_consume(options, :auth_token)
@@ -578,7 +575,7 @@ class Cloudinary::Utils
     transformation = transformation.gsub(%r(([^:])//), '\1/')
     if sign_url && ( !auth_token || auth_token.empty?)
       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 = [transformation, source_to_sign].reject(&:blank?).join("/")
       to_sign = fully_unescape(to_sign)
       signature_algorithm = long_url_signature ? ALGO_SHA256 : signature_algorithm
       hash = hash("#{to_sign}#{secret}", signature_algorithm)
@@ -590,12 +587,22 @@ class Cloudinary::Utils
     prefix = build_distribution_domain(options)
 
     source = [prefix, resource_type, type, signature, transformation, version, source].reject(&:blank?).join("/")
+
+    token = nil
     if sign_url && auth_token && !auth_token.empty?
       auth_token[:url] = URI.parse(source).path
       token = Cloudinary::AuthToken.generate auth_token
-      source += "?#{token}"
     end
 
+    analytics = config_option_consume(options, :analytics, true)
+    analytics_token = nil
+    if analytics && ! original_source.include?("?") # Disable analytics for public IDs containing query params.
+      analytics_token = Cloudinary::Analytics.sdk_analytics_query_param
+    end
+
+    query_params = [token, analytics_token].compact.join("&")
+
+    source += "?#{query_params}" unless query_params.empty?
     source
   end
 
@@ -678,7 +685,7 @@ class Cloudinary::Utils
     shared_domain = !private_cdn
 
     if secure
-      if secure_distribution.nil? || secure_distribution == Cloudinary::OLD_AKAMAI_SHARED_CDN
+      if secure_distribution.nil?
         secure_distribution = private_cdn ? "#{cloud_name}-res.cloudinary.com" : Cloudinary::SHARED_CDN
       end
       shared_domain ||= secure_distribution == Cloudinary::SHARED_CDN
@@ -705,9 +712,7 @@ class Cloudinary::Utils
     cloud_name = config_option_consume(options, :cloud_name) || raise(CloudinaryException, "Must supply cloud_name in tag or in configuration")
 
     source = options.delete(:source)
-    secure = options.delete(:secure)
-    ssl_detected = options.delete(:ssl_detected)
-    secure = ssl_detected || Cloudinary.config.secure if secure.nil?
+    secure = config_option_consume(options, :secure, true)
     private_cdn = config_option_consume(options, :private_cdn)
     secure_distribution = config_option_consume(options, :secure_distribution)
     cname = config_option_consume(options, :cname)
@@ -726,8 +731,9 @@ class Cloudinary::Utils
   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')
+    api_version = options[:api_version] || Cloudinary.config.api_version || 'v1_1'
 
-    [cloudinary, 'v1_1', cloud_name, path].join('/')
+    [cloudinary, api_version, cloud_name, path].join('/')
   end
 
   def self.cloudinary_api_url(action = 'upload', options = {})
@@ -796,14 +802,6 @@ class Cloudinary::Utils
     return Cloudinary::Utils.cloudinary_api_url("download", options) + "?" + hash_query_params(cloudinary_params)
   end
 
-  # Utility method that uses the deprecated ZIP download API.
-  # @deprecated Replaced by {download_zip_url} that uses the more advanced and robust archive generation and download API
-  def self.zip_download_url(tag, options = {})
-    warn "zip_download_url is deprecated. Please use download_zip_url instead."
-    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) + "?" + hash_query_params(cloudinary_params)
-  end
-
   # Returns a URL that when invokes creates an archive and returns it.
   # @param options [Hash]
   # @option options [String|Symbol] :resource_type  The resource type of files to include in the archive. Must be one of :image | :video | :raw
@@ -853,31 +851,6 @@ class Cloudinary::Utils
     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
-      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)
-      return signer.sign(url, :ending => expires_at)
-    else
-      return Cloudinary::Utils.unsigned_download_url( public_id, options)
-    end
-
-  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
@@ -1305,22 +1278,26 @@ class Cloudinary::Utils
   # Handles file parameter.
   #
   # @param [Pathname, StringIO, File, String, int, _ToPath] file
-  # @return [StringIO, File] A File object.
+  # @return [StringIO, File, String] A File object.
   #
   # @private
   def self.handle_file_param(file, options = {})
+    original_filename = options[:original_filename] || "cloudinaryfile"
+    content_type = options[:content_type] || "application/octet-stream"
     if file.is_a?(Pathname)
-      return File.open(file, "rb")
+      return Faraday::FilePart.new(file.to_s, content_type)
     elsif file.is_a?(Cloudinary::Blob)
-      return file
+      return Faraday::FilePart.new(file, file.content_type, file.original_filename)
     elsif file.is_a?(StringIO)
       file.rewind
-      return Cloudinary::Blob.new(file.read, options)
-    elsif file.respond_to?(:read) || Cloudinary::Utils.is_remote?(file)
-      return file
+      return Faraday::FilePart.new(file, content_type, original_filename)
+    elsif file.respond_to?(:read)
+      return Faraday::FilePart.new(file, content_type, original_filename)
+    elsif Cloudinary::Utils.is_remote?(file)
+      return file.to_s
     end
-
-    File.open(file, "rb")
+    # we got file path
+    Faraday::FilePart.new(file.to_s, content_type)
   end
 
   # The returned url should allow downloading the backedup asset based on the version and asset id

data/lib/cloudinary/version.rb

@@ -1,4 +1,4 @@
 # Copyright Cloudinary
 module Cloudinary
-  VERSION = "1.29.0"
+  VERSION = "2.3.0"
 end

data/lib/cloudinary.rb

@@ -1,10 +1,6 @@
 # Copyright Cloudinary
-if RUBY_VERSION > "2"
-  require "ostruct"
-else
-  require "cloudinary/ostruct2"
-end
 
+require "ostruct"
 require "pathname"
 require "yaml"
 require "uri"
@@ -29,11 +25,9 @@ module Cloudinary
   autoload :CarrierWave, "cloudinary/carrier_wave"
   autoload :Search, "cloudinary/search"
   autoload :SearchFolders, "cloudinary/search_folders"
+  autoload :Analytics, "cloudinary/analytics"
 
-  CF_SHARED_CDN         = "d3jpl91pxevbkh.cloudfront.net"
-  AKAMAI_SHARED_CDN     = "res.cloudinary.com"
-  OLD_AKAMAI_SHARED_CDN = "cloudinary-a.akamaihd.net"
-  SHARED_CDN            = AKAMAI_SHARED_CDN
+  SHARED_CDN      = "res.cloudinary.com"
 
   USER_AGENT      = "CloudinaryRuby/#{VERSION} (Ruby #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL})"
   @@user_platform = defined?(Rails.version) ? "Rails/#{Rails.version}" : ""

data/lib/tasks/cloudinary/fetch_assets.rake

@@ -1,7 +1,9 @@
 require 'tmpdir'
-require 'rest_client'
+require 'faraday'
+require 'faraday/follow_redirects'
 require 'json'
 require 'rubygems/package'
+require 'stringio'
 
 unless Rake::Task.task_defined?('cloudinary:fetch_assets') # prevent double-loading/execution
   namespace :cloudinary do
@@ -11,7 +13,7 @@ unless Rake::Task.task_defined?('cloudinary:fetch_assets') # prevent double-load
       processing_files = %w[canvas-to-blob.min.js load-image.all.min.js jquery.fileupload-process.js jquery.fileupload-image.js jquery.fileupload-validate.js]
       files = index_files + processing_files
 
-      release = JSON(RestClient.get("https://api.github.com/repos/cloudinary/cloudinary_js/releases/latest"))
+      release = JSON(Faraday.get("https://api.github.com/repos/cloudinary/cloudinary_js/releases/latest").body)
 
       FileUtils.rm_rf 'vendor/assets'
       html_folder = 'vendor/assets/html'
@@ -20,7 +22,11 @@ unless Rake::Task.task_defined?('cloudinary:fetch_assets') # prevent double-load
       FileUtils.mkdir_p js_folder
 
       puts "Fetching cloudinary_js version #{release["tag_name"]}\n\n"
-      sio = StringIO.new(RestClient.get(release["tarball_url"]).body)
+      conn = Faraday.new do |faraday|
+        faraday.response :follow_redirects
+        faraday.adapter Faraday.default_adapter
+      end
+      sio = StringIO.new(conn.get(release["tarball_url"]).body)
       file = Zlib::GzipReader.new(sio)
       tar = Gem::Package::TarReader.new(file)
       tar.each_entry do |entry|

data/vendor/assets/javascripts/cloudinary/jquery.cloudinary.js

@@ -422,7 +422,7 @@ var slice = [].slice,
    * @returns {boolean} true if item is empty
    */
   isEmpty = function(item) {
-    return (item == null) || (jQuery.isArray(item) || Util.isString(item)) && item.length === 0 || (jQuery.isPlainObject(item) && jQuery.isEmptyObject(item));
+    return (item == null) || (Array.isArray(item) || Util.isString(item)) && item.length === 0 || (jQuery.isPlainObject(item) && jQuery.isEmptyObject(item));
   };
 
   /**
@@ -565,7 +565,7 @@ var slice = [].slice,
     setData: setData,
     width: width,
     isString: isString,
-    isArray: jQuery.isArray,
+    isArray: Array.isArray,
     isEmpty: isEmpty,
 
     /**
@@ -4728,7 +4728,7 @@ var slice = [].slice,
           return k + '=' + v;
         }).join('|');
       } else if (Util.isArray(value)) {
-        if (value.length > 0 && jQuery.isArray(value[0])) {
+        if (value.length > 0 && Array.isArray(value[0])) {
           upload_params[key] = jQuery.map(value, function(array_value) {
             return array_value.join(',');
           }).join('|');