cloudinary 1.28.0 → 2.0.0

data/lib/cloudinary/api.rb

@@ -68,7 +68,7 @@ class Cloudinary::Api
     type          = options[:type]
     uri           = "resources/#{resource_type}"
     uri           += "/#{type}" unless type.blank?
-    call_api(:get, uri, only(options, :next_cursor, :max_results, :prefix, :tags, :context, :moderations, :direction, :start_at, :metadata), options)
+    call_api(:get, uri, list_resources_params(options).merge(only(options, :prefix, :start_at)), options)
   end
 
   # Lists assets with the specified tag.
@@ -87,7 +87,7 @@ class Cloudinary::Api
   def self.resources_by_tag(tag, options={})
     resource_type = options[:resource_type] || "image"
     uri           = "resources/#{resource_type}/tags/#{tag}"
-    call_api(:get, uri, only(options, :next_cursor, :max_results, :tags, :context, :moderations, :direction, :metadata), options)
+    call_api(:get, uri, list_resources_params(options), options)
   end
 
   # Lists assets currently in the specified moderation queue and status.
@@ -107,7 +107,7 @@ class Cloudinary::Api
   def self.resources_by_moderation(kind, status, options={})
     resource_type = options[:resource_type] || "image"
     uri           = "resources/#{resource_type}/moderations/#{kind}/#{status}"
-    call_api(:get, uri, only(options, :next_cursor, :max_results, :tags, :context, :moderations, :direction, :metadata), options)
+    call_api(:get, uri, list_resources_params(options), options)
   end
 
   # Lists assets with the specified contextual metadata.
@@ -129,30 +129,9 @@ class Cloudinary::Api
   def self.resources_by_context(key, value=nil, options={})
     resource_type = options[:resource_type] || "image"
     uri           = "resources/#{resource_type}/context"
-    params = only(options, :next_cursor, :max_results, :tags, :context, :moderations, :direction, :key, :value, :metadata)
-    params[:key] = key
-    params[:value] = value
-    call_api(:get, uri, params, options)
+    call_api(:get, uri, list_resources_params(options, :key => key, :value => value), options)
   end
 
-  # Returns the details of the specified asset and all its derived assets by asset id.
-  # 
-  # Note that if you only need details about the original asset,
-  # you can also use the Uploader::upload or Uploader::explicit methods, which return the same information and
-  # are not rate limited.
-  # 
-  # @param [String] asset_id The Asset ID of the asset.
-  # @param [Hash]   options  The optional parameters. See the <a href=https://cloudinary.com/documentation/admin_api#get_the_details_of_a_single_resource target="_blank"> Admin API</a> documentation.
-  # 
-  # @return [Cloudinary::Api::Response]
-  # 
-  # @see https://cloudinary.com/documentation/admin_api#get_the_details_of_a_single_resource
-  def self.resource_by_asset_id(asset_id, options={})
-    uri    = "resources/#{asset_id}"
-    params = prepare_resource_details_params(options)
-    call_api(:get, uri, params, options)
-  end
-  
   # Lists assets with the specified public IDs.
   #
   # @param [String|Array] public_ids The requested public_ids (up to 100).
@@ -168,7 +147,7 @@ class Cloudinary::Api
     resource_type = options[:resource_type] || "image"
     type          = options[:type] || "upload"
     uri           = "resources/#{resource_type}/#{type}"
-    call_api(:get, uri, only(options, :tags, :context, :moderations).merge(:public_ids => public_ids), options)
+    call_api(:get, uri, resources_params(options, :public_ids => public_ids), options)
   end
 
   # Lists assets with the specified asset IDs.
@@ -184,9 +163,7 @@ class Cloudinary::Api
   # @see https://cloudinary.com/documentation/admin_api#get_resources
   def self.resources_by_asset_ids(asset_ids, options={})
     uri = "resources/by_asset_ids"
-    params = only(options, :public_ids, :tags, :moderations, :context)
-    params[:asset_ids] = asset_ids
-    call_api(:get, uri, params, options)
+    call_api(:get, uri, resources_params(options, :asset_ids => asset_ids), options)
   end
 
   # Returns all assets stored directly in a specified asset folder, regardless of the public ID paths of those assets.
@@ -202,9 +179,7 @@ class Cloudinary::Api
   # @see https://cloudinary.com/documentation/dynamic_folders#new_admin_api_endpoints
   def self.resources_by_asset_folder(asset_folder, options={})
     uri = "resources/by_asset_folder"
-    params = only(options, :next_cursor, :max_results, :tags, :context, :moderations, :direction, :key, :value, :metadata)
-    params[:asset_folder] = asset_folder
-    call_api(:get, uri, params, options)
+    call_api(:get, uri, list_resources_params(options, :asset_folder => asset_folder), options)
   end
 
   # Find images based on their visual content.
@@ -243,6 +218,23 @@ class Cloudinary::Api
     call_api(:get, uri, prepare_resource_details_params(options), options)
   end
 
+  # Returns the details of the specified asset and all its derived assets by asset id.
+  #
+  # Note that if you only need details about the original asset,
+  # you can also use the Uploader::upload or Uploader::explicit methods, which return the same information and
+  # are not rate limited.
+  #
+  # @param [String] asset_id The Asset ID of the asset.
+  # @param [Hash]   options  The optional parameters. See the <a href=https://cloudinary.com/documentation/admin_api#get_the_details_of_a_single_resource target="_blank"> Admin API</a> documentation.
+  #
+  # @return [Cloudinary::Api::Response]
+  #
+  # @see https://cloudinary.com/documentation/admin_api#get_the_details_of_a_single_resource
+  def self.resource_by_asset_id(asset_id, options={})
+    uri    = "resources/#{asset_id}"
+    call_api(:get, uri, prepare_resource_details_params(options), options)
+  end
+
   # Reverts to the latest backed up version of the specified deleted assets.
   #
   # @param [String|Array] public_ids The public IDs of the backed up assets to restore. They can be existing or
@@ -657,7 +649,7 @@ class Cloudinary::Api
   #
   # @see https://cloudinary.com/documentation/admin_api#update_an_upload_preset
   def self.update_upload_preset(name, options={})
-    params = Cloudinary::Uploader.build_upload_params(options)
+    params = Cloudinary::Uploader.build_upload_params(options, true)
     call_api(:put, "upload_presets/#{name}", params.merge(only(options, :unsigned, :disallow_public_id, :live)), options)
   end
 
@@ -672,7 +664,7 @@ class Cloudinary::Api
   #
   # @see https://cloudinary.com/documentation/admin_api#create_an_upload_preset
   def self.create_upload_preset(options={})
-    params = Cloudinary::Uploader.build_upload_params(options)
+    params = Cloudinary::Uploader.build_upload_params(options, true)
     call_api(:post, "upload_presets", params.merge(only(options, :name, :unsigned, :disallow_public_id, :live)), options)
   end
 
@@ -1230,6 +1222,25 @@ class Cloudinary::Api
     call_metadata_rules_api(:delete, uri, {}, options)
   end
 
+  # Analyzes an asset with the requested analysis type.
+  #
+  # @param [Object] input_type    The type of input for the asset to analyze ('uri').
+  # @param [Object] analysis_type The type of analysis to run ('google_tagging', 'captioning', 'fashion').
+  # @param [Hash] options         The optional parameters.
+  #
+  # @return [Cloudinary::Api::Response]
+  #
+  # @raise [Cloudinary::Api::Error]
+  def self.analyze(input_type, analysis_type, options = {})
+    api_uri = ["analysis", "analyze", input_type]
+    params = only(options, :uri, :parameters)
+    params["analysis_type"] = analysis_type
+
+    options[:api_version] = 'v2'
+
+    call_api(:post, api_uri, params, options)
+  end
+
   protected
 
   # Execute a call api for input params.
@@ -1244,13 +1255,14 @@ class Cloudinary::Api
     api_key     = options[:api_key] || Cloudinary.config.api_key
     api_secret  = options[:api_secret] || Cloudinary.config.api_secret
     oauth_token = options[:oauth_token] || Cloudinary.config.oauth_token
+    api_version = options[:api_version] || Cloudinary.config.api_version || 'v1_1'
 
     validate_authorization(api_key, api_secret, oauth_token)
 
     auth = { :key => api_key, :secret => api_secret, :oauth_token => oauth_token }
 
     call_cloudinary_api(method, uri, auth, params, options) do |cloudinary, inner_uri|
-      [cloudinary, 'v1_1', cloud_name, inner_uri]
+      [cloudinary, api_version, cloud_name, inner_uri]
     end
   end
 
@@ -1262,7 +1274,7 @@ class Cloudinary::Api
     return Cloudinary::Utils.json_decode(response.body)
   rescue => e
     # Error is parsing json
-    raise GeneralError.new("Error parsing server response (#{response.code}) - #{response.body}. Got - #{e}")
+    raise GeneralError.new("Error parsing server response (#{response.status}) - #{response.body}. Got - #{e}")
   end
 
   # Protected function that assists with performing an API call to the metadata_fields part of the Admin API.
@@ -1399,4 +1411,19 @@ class Cloudinary::Api
     params[by_key] = value
     call_api("post", "resources/#{resource_type}/#{type}/update_access_mode", params, options)
   end
+
+  private
+
+  RESOURCES_PARAMS = [:tags, :context, :metadata, :moderations, :fields].freeze
+  LIST_RESOURCES_PARAMS = [:next_cursor, :max_results, :direction].freeze
+
+  def self.resources_params(options, params = {})
+    params.merge!(only(options, *RESOURCES_PARAMS))
+    params[:fields] = Cloudinary::Utils.build_array(options[:fields]).join(",") unless params[:fields].nil?
+    params
+  end
+
+  def self.list_resources_params(options, params = {})
+    params.merge(resources_params(options)).merge!(only(options, *LIST_RESOURCES_PARAMS))
+  end
 end

data/lib/cloudinary/auth_token.rb

@@ -1,11 +1,7 @@
 # frozen_string_literal: true
 
 require 'openssl'
-if RUBY_VERSION > "2"
-  require "ostruct"
-else
-  require "cloudinary/ostruct2"
-end
+require "ostruct"
 
 
 module Cloudinary

data/lib/cloudinary/base_api.rb

@@ -1,7 +1,8 @@
-require "rest_client"
+require "faraday"
 require "json"
 
 module Cloudinary::BaseApi
+  @adapter = nil
   class Error < CloudinaryException; end
   class NotFound < Error; end
   class NotAllowed < Error; end
@@ -15,17 +16,19 @@ module Cloudinary::BaseApi
     attr_reader :rate_limit_reset_at, :rate_limit_remaining, :rate_limit_allowed
 
     def initialize(response=nil)
-      if response
-        # This sets the instantiated self as the response Hash
-        update Cloudinary::Api.parse_json_response response
+      unless response
+        return
+      end
 
-        # According to RFC 2616, header names are case-insensitive.
-        lc_headers = response.headers.transform_keys(&:downcase)
+      # This sets the instantiated self as the response Hash
+      update Cloudinary::Api.parse_json_response response
 
-        @rate_limit_allowed   = lc_headers[:x_featureratelimit_limit].to_i if lc_headers[:x_featureratelimit_limit]
-        @rate_limit_reset_at  = Time.parse(lc_headers[:x_featureratelimit_reset]) if lc_headers[:x_featureratelimit_reset]
-        @rate_limit_remaining = lc_headers[:x_featureratelimit_remaining].to_i if lc_headers[:x_featureratelimit_remaining]
-      end
+      # According to RFC 2616, header names are case-insensitive.
+      lc_headers            = response.headers.transform_keys(&:downcase)
+
+      @rate_limit_allowed   = lc_headers["x-featureratelimit-limit"].to_i if lc_headers["x-featureratelimit-limit"]
+      @rate_limit_reset_at  = Time.parse(lc_headers["x-featureratelimit-reset"]) if lc_headers["x-featureratelimit-reset"]
+      @rate_limit_remaining = lc_headers["x-featureratelimit-remaining"].to_i if lc_headers["x-featureratelimit-remaining"]
     end
   end
 
@@ -36,28 +39,30 @@ module Cloudinary::BaseApi
   end
 
   def call_json_api(method, api_url, payload, timeout, headers, proxy = nil, user = nil, password = nil)
-    RestClient::Request.execute(method: method,
-                                url: api_url,
-                                payload: payload,
-                                timeout: timeout,
-                                headers: headers,
-                                proxy: proxy,
-                                user: user,
-                                password: password) do |response|
-      return Response.new(response) if response.code == 200
-      exception_class = case response.code
-                        when 400 then BadRequest
-                        when 401 then AuthorizationRequired
-                        when 403 then NotAllowed
-                        when 404 then NotFound
-                        when 409 then AlreadyExists
-                        when 420 then RateLimited
-                        when 500 then GeneralError
-                        else raise GeneralError.new("Server returned unexpected status code - #{response.code} - #{response.body}")
-                        end
-      json = Cloudinary::Api.parse_json_response(response)
-      raise exception_class.new(json["error"]["message"])
+    conn = Faraday.new(url: api_url) do |faraday|
+      faraday.proxy = proxy if proxy
+      faraday.request :json
+      faraday.adapter @adapter || Faraday.default_adapter
     end
+
+    response = conn.run_request(method.downcase.to_sym, nil, payload, headers) do |req|
+      req.options.timeout = timeout if timeout
+      req.basic_auth(user, password) if user && password
+    end
+
+    return Response.new(response) if response.status == 200
+    exception_class = case response.status
+                      when 400 then BadRequest
+                      when 401 then AuthorizationRequired
+                      when 403 then NotAllowed
+                      when 404 then NotFound
+                      when 409 then AlreadyExists
+                      when 420 then RateLimited
+                      when 500 then GeneralError
+                      else raise GeneralError.new("Server returned unexpected status code - #{response.status} - #{response.body}")
+                      end
+    json = Cloudinary::Api.parse_json_response(response)
+    raise exception_class.new(json["error"]["message"])
   end
 
   private

data/lib/cloudinary/carrier_wave/storage.rb

@@ -36,7 +36,8 @@ class Cloudinary::CarrierWave::Storage < ::CarrierWave::Storage::Abstract
       params[:type]=uploader.class.storage_type
 
       params[:resource_type] ||= :auto
-      uploader.metadata = Cloudinary::Uploader.upload(data, params)
+      upload_method = uploader.upload_chunked? ? "upload_large" : "upload"
+      uploader.metadata = Cloudinary::Uploader.send(upload_method, data, params)
       if uploader.metadata["error"]
         raise Cloudinary::CarrierWave::UploadError.new(uploader.metadata["error"]["message"], uploader.metadata["error"]["http_code"])
       end

data/lib/cloudinary/carrier_wave.rb

@@ -192,11 +192,6 @@ module Cloudinary::CarrierWave
 
   end
 
-  # @deprecated
-  def self.split_format(identifier)
-    return Cloudinary::PreloadedFile.split_format(identifier)
-  end
-
   def default_format
     "png"
   end

data/lib/cloudinary/helper.rb

@@ -286,13 +286,6 @@ module CloudinaryHelper
     Cloudinary::Utils.private_download_url(public_id, format, options)
   end
 
-  # 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 = {})
-    Cloudinary::Utils.zip_download_url(tag, options)
-  end
-
   # @see {Cloudinary::Utils.download_archive_url}
   def cl_download_archive_url(options = {})
     Cloudinary::Utils.download_archive_url(options)
@@ -304,13 +297,13 @@ module CloudinaryHelper
   end
 
   def cl_signed_download_url(public_id, options = {})
-    Cloudinary::Utils.signed_download_url(public_id, options)
+    Cloudinary::Utils.cloudinary_url(public_id, options)
   end
 
   def self.included(base)
     ActionView::Helpers::FormBuilder.send(:include, Cloudinary::FormBuilder)
     base.class_eval do
-      if !method_defined?(:image_tag)
+      unless method_defined?(:image_tag)
         include ActionView::Helpers::AssetTagHelper
       end
       alias_method :image_tag_without_cloudinary, :image_tag unless public_method_defined? :image_tag_without_cloudinary
@@ -325,7 +318,6 @@ module CloudinaryHelper
   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)
       if source.version_name.present?
         options[:transformation] = Cloudinary::Utils.build_array(source.transformation) + Cloudinary::Utils.build_array(options[:transformation])