cloudinary 1.29.0 → 2.3.0

data/lib/cloudinary/api.rb

@@ -14,6 +14,22 @@ class Cloudinary::Api
     call_api(:get, "ping", {}, options)
   end
 
+  # Retrieves account configuration details.
+  #
+  # @param [Hash] options The optional parameters.
+  #
+  # @return [Cloudinary::Api::Response]
+  #
+  # @raise [Cloudinary::Api::Error]
+  #
+  # @see https://cloudinary.com/documentation/admin_api#config
+  def self.config(options={})
+    uri = "config"
+    params = only(options, :settings)
+
+    call_api(:get, uri, params, options)
+  end
+
   # Gets cloud usage details.
   #
   # Returns a report detailing your current Cloudinary cloud usage details, including
@@ -649,7 +665,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
 
@@ -664,7 +680,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
 
@@ -731,6 +747,21 @@ class Cloudinary::Api
     call_api(:post, "folders/#{folder_name}", {}, options)
   end
 
+  # Renames existing asset folder.
+  #
+  # @param [String] from_path The full path of an existing asset folder.
+  # @param [String] to_path   The full path of the new asset folder.
+  # @param [Hash]   options   The optional parameters.
+  #
+  # @return [Cloudinary::Api::Response]
+  #
+  # @raise [Cloudinary::Api::Error]
+  #
+  # @see https://cloudinary.com/documentation/admin_api#rename_folder
+  def self.rename_folder(from_path, to_path, options={})
+    call_api(:put, "folders/#{from_path}", {:to_folder => to_path}, options)
+  end
+
   # Lists upload mappings by folder and its mapped template (URL).
   #
   # @param [Hash] options The optional parameters. See the
@@ -1006,9 +1037,7 @@ class Cloudinary::Api
   #
   # @see https://cloudinary.com/documentation/admin_api#create_a_metadata_field
   def self.add_metadata_field(field, options = {})
-    params = only(field, :type, :external_id, :label, :mandatory, :default_value, :validation, :datasource)
-
-    call_metadata_api(:post, [], params, options)
+    call_metadata_api(:post, [], prepare_metadata_field_params(field), options)
   end
 
   # Updates a metadata field by external ID.
@@ -1025,10 +1054,19 @@ class Cloudinary::Api
   #
   # @see https://cloudinary.com/documentation/admin_api#update_a_metadata_field_by_external_id
   def self.update_metadata_field(field_external_id, field, options = {})
-    uri = [field_external_id]
-    params = only(field, :label, :mandatory, :default_value, :validation)
+    uri    = [field_external_id]
 
-    call_metadata_api(:put, uri, params, options)
+    call_metadata_api(:put, uri, prepare_metadata_field_params(field), options)
+  end
+
+  # Prepares optional parameters for add/update_metadata_field API calls.
+  # @param  [Hash]   options Additional options
+  # @return [Object]         Optional parameters
+  def self.prepare_metadata_field_params(field)
+    only(field,
+         :type, :external_id, :label, :mandatory, :restrictions, :default_value, :default_disabled,
+         :validation, :datasource, :allow_dynamic_list_values
+    )
   end
 
   # Deletes a metadata field definition by external ID.
@@ -1222,6 +1260,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.
@@ -1236,13 +1293,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
 
@@ -1254,7 +1312,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.

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, 429 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.respond_to?(:upload_chunked?) && 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

@@ -179,7 +179,7 @@ module CloudinaryHelper
     version_store = options.delete(:version_store)
     if options[:version].blank? && (version_store == :file) && defined?(Rails) && defined?(Rails.root)
       file_name = "#{Rails.root}/tmp/cloudinary/cloudinary_sprite_#{source.sub(/\..*/, '')}.version"
-      if File.exists?(file_name)
+      if File.exist?(file_name)
         options[:version] = File.read(file_name).chomp
       end
     end
@@ -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])

data/lib/cloudinary/migrator.rb

@@ -6,29 +6,29 @@ class Cloudinary::Migrator
   attr_reader :db
   attr_reader :work, :results, :mutex
   attr_reader :extra_options
-  
-  
+
+
   @@init = false
   def self.init
     return if @@init
     @@init = true
 
-    begin 
+    begin
       require 'sqlite3'
     rescue LoadError
-      raise "Please add sqlite3 to your Gemfile"    
+      raise "Please add sqlite3 to your Gemfile"
     end
     require 'tempfile'
   end
-  
+
   def json_decode(str)
     Cloudinary::Utils.json_decode(str)
   end
-    
+
   def initialize(options={})
     self.class.init
-    
-    options[:db_file] = "tmp/migration#{$$}.db" if options[:private_database] && !options[:db_file] 
+
+    options[:db_file] = "tmp/migration#{$$}.db" if options[:private_database] && !options[:db_file]
     @dbfile = options[:db_file] || "tmp/migration.db"
     FileUtils.mkdir_p(File.dirname(@dbfile))
     @db = SQLite3::Database.new @dbfile, :results_as_hash=>true
@@ -37,7 +37,6 @@ class Cloudinary::Migrator
     @debug = options[:debug] || false
     @ignore_duplicates = options[:ignore_duplicates]
     @threads = [options[:threads] || 10, 100].min
-    @threads = 1 if RUBY_VERSION < "1.9"
     @extra_options = {:api_key=>options[:api_key], :api_secret=>options[:api_secret]}
     @delete_after_done = options[:delete_after_done] || options[:private_database]
     @max_processing = @threads * 10
@@ -77,7 +76,7 @@ class Cloudinary::Migrator
       @db.execute("delete from queue")
     end
   end
-    
+
   def register_retrieve(&block)
     @retrieve = block
   end
@@ -85,26 +84,26 @@ class Cloudinary::Migrator
   def register_complete(&block)
     @complete = block
   end
-  
-  def process(options={})    
+
+  def process(options={})
     raise CloudinaryException, "url not given and no retrieve callback given" if options[:url].nil? && self.retrieve.nil?
     raise CloudinaryException, "id not given and retrieve or complete callback given" if options[:id].nil? && (!self.retrieve.nil? || !self.complete.nil?)
 
     debug("Process: #{options.inspect}")
     start
-    process_results    
+    process_results
     wait_for_queue
     options = options.dup
     id = options.delete(:id)
     url = options.delete(:url)
     public_id = options.delete(:public_id)
     row = {
-      "internal_id"=>id, 
-      "url"=>url, 
-      "public_id"=>public_id, 
+      "internal_id"=>id,
+      "url"=>url,
+      "public_id"=>public_id,
       "metadata"=>options.to_json,
-      "status"=>"processing"      
-    }    
+      "status"=>"processing"
+    }
     begin
       insert_row(row)
       add_to_work_queue(row)
@@ -112,7 +111,7 @@ class Cloudinary::Migrator
       raise if !@ignore_duplicates
     end
   end
-      
+
   def done
     start
     process_all_pending
@@ -122,37 +121,37 @@ class Cloudinary::Migrator
     @db.close
     File.delete(@dbfile) if @delete_after_done
   end
-  
+
   def max_given_id
     db.get_first_value("select max(internal_id) from queue").to_i
   end
-  
+
   def close_if_needed(file)
     if file.nil?
       # Do nothing.
-    elsif file.respond_to?(:close!) 
-      file.close! 
+    elsif file.respond_to?(:close!)
+      file.close!
     elsif file.respond_to?(:close)
       file.close
     end
   rescue
     # Ignore errors in closing files
-  end  
+  end
 
-  def temporary_file(data, filename)  
-    file = RUBY_VERSION == "1.8.7" ? Tempfile.new('cloudinary') : Tempfile.new('cloudinary', :encoding => 'ascii-8bit')
+  def temporary_file(data, filename)
+    file = Tempfile.new('cloudinary', :encoding => 'ascii-8bit')
     file.unlink
     file.write(data)
     file.rewind
-    # Tempfile return path == nil after unlink, which break rest-client              
+    # Tempfile return path == nil after unlink, which break rest-client
     class << file
       attr_accessor :original_filename
       def content_type
-        "application/octet-stream"                  
+        "application/octet-stream"
       end
     end
     file.original_filename = filename
-    file                  
+    file
   end
 
   private
@@ -160,21 +159,21 @@ class Cloudinary::Migrator
   def update_all(values)
     @db.execute("update queue set #{values.keys.map{|key| "#{key}=?"}.join(",")}", *values.values)
   end
-  
-  def update_row(row, values)    
+
+  def update_row(row, values)
     values.merge!("updated_at"=>Time.now.to_i)
     query = ["update queue set #{values.keys.map{|key| "#{key}=?"}.join(",")} where id=?"] + values.values + [row["id"]]
     @db.execute(*query)
     values.each{|key, value| row[key.to_s] = value}
-    row    
+    row
   end
-  
+
   def insert_row(values)
     values.merge!("updated_at"=>Time.now.to_i)
     @db.execute("insert into queue (#{values.keys.join(",")}) values (#{values.keys.map{"?"}.join(",")})", *values.values)
     values["id"] = @db.last_insert_row_id
   end
-  
+
   def refill_queue(last_id)
     @db.execute("select * from queue where status in ('error', 'processing') and id > ? limit ?", last_id, 10000) do
       |row|
@@ -183,25 +182,25 @@ class Cloudinary::Migrator
       add_to_work_queue(row)
     end
     last_id
-  end 
+  end
 
   def process_results
     while self.results.length > 0
       row = self.results.pop
-      result = json_decode(row["result"])      
+      result = json_decode(row["result"])
       debug("Done ID=#{row['internal_id']}, result=#{result.inspect}")
-      complete.call(row["internal_id"], result) if complete 
-      if result["error"]        
+      complete.call(row["internal_id"], result) if complete
+      if result["error"]
         status = case result["error"]["http_code"]
         when 400, 404 then "fatal" # Problematic request. Not a server problem.
         else "error"
         end
       else
         status = "completed"
-      end       
+      end
       updates = {:status=>status, :result=>row["result"]}
       updates["public_id"] = result["public_id"] if result["public_id"] && !row["public_id"]
-      begin 
+      begin
         update_row(row, updates)
       rescue SQLite3::ConstraintException
         updates = {:status=>"error", :result=>{:error=>{:message=>"public_id already exists"}}.to_json}
@@ -219,16 +218,16 @@ class Cloudinary::Migrator
       raise if retry_count > tries
       sleep rand * 3
       retry
-    end  
+    end
   end
-  
+
   def start
     return if @started
     @started = true
     @terminate = false
-    
+
     self.work.clear
-    
+
     main = self
     Thread.abort_on_exception = true
     1.upto(@threads) do
@@ -251,8 +250,8 @@ class Cloudinary::Migrator
               elsif defined?(::CarrierWave) && defined?(Cloudinary::CarrierWave) && data.is_a?(Cloudinary::CarrierWave)
                 cw = true
                 begin
-                  data.model.save! 
-                rescue Cloudinary::CarrierWave::UploadError 
+                  data.model.save!
+                rescue Cloudinary::CarrierWave::UploadError
                   # upload errors will be handled by the result values.
                 end
                 result = data.metadata
@@ -264,22 +263,22 @@ class Cloudinary::Migrator
               elsif data.match(/^https?:/)
                 url = data
               else
-                file = main.temporary_file(data, row["public_id"] || "cloudinaryfile") 
+                file = main.temporary_file(data, row["public_id"] || "cloudinaryfile")
               end
             end
-            
+
             if url || file
               options = main.extra_options.merge(:public_id=>row["public_id"])
               json_decode(row["metadata"]).each do
                 |key, value|
                 options[key.to_sym] = value
               end
-                          
+
               result = Cloudinary::Uploader.upload(url || file, options.merge(:return_error=>true)) || ({:error=>{:message=>"Received nil from uploader!"}})
             elsif cw
               result ||= {"status" => "saved"}
             else
-              result = {"error" => {"message" => "Empty data and url", "http_code"=>404}} 
+              result = {"error" => {"message" => "Empty data and url", "http_code"=>404}}
             end
             main.results << {"id"=>row["id"], "internal_id"=>row["internal_id"], "result"=>result.to_json}
           rescue => e
@@ -289,14 +288,14 @@ class Cloudinary::Migrator
           ensure
             main.mutex.synchronize{main.in_process -= 1}
             main.close_if_needed(file)
-          end          
+          end
         end
       end
-    end 
-    
+    end
+
     retry_previous_queue # Retry all work from previous iteration before we start processing this one.
   end
-  
+
   def debug(message)
     if @debug
       mutex.synchronize{
@@ -310,60 +309,60 @@ class Cloudinary::Migrator
     begin
       prev_last_id, last_id = last_id, refill_queue(last_id)
     end while last_id > prev_last_id
-    process_results    
+    process_results
   end
-  
+
   def process_all_pending
     # Waiting for work to finish. While we are at it, process results.
-    while self.in_process > 0      
+    while self.in_process > 0
       process_results
       sleep 0.1
     end
     # Make sure we processed all the results
     process_results
   end
-  
+
   def add_to_work_queue(row)
     self.work << row
     mutex.synchronize{self.in_process += 1}
   end
-  
+
   def wait_for_queue
     # Waiting f
     while self.work.length > @max_processing
-      process_results    
+      process_results
       sleep 0.1
-    end    
+    end
   end
 
-  def self.sample        
+  def self.sample
     migrator = Cloudinary::Migrator.new(
-      :retrieve=>proc{|id| Post.find(id).data}, 
+      :retrieve=>proc{|id| Post.find(id).data},
       :complete=>proc{|id, result| a}
       )
-    
+
     Post.find_each(:conditions=>["id > ?", migrator.max_given_id], :select=>"id") do
       |post|
       migrator.process(:id=>post.id, :public_id=>"post_#{post.id}")
     end
     migrator.done
-  end 
-    
-  def self.test  
+  end
+
+  def self.test
     posts = {}
-    done = {}      
+    done = {}
     migrator = Cloudinary::Migrator.new(
-      :retrieve=>proc{|id| posts[id]}, 
+      :retrieve=>proc{|id| posts[id]},
       :complete=>proc{|id, result| $stderr.print "done #{id} #{result}\n"; done[id] = result}
       )
     start = migrator.max_given_id + 1
     (start..1000).each{|i| posts[i] = "hello#{i}"}
-    
+
     posts.each do
       |id, data|
       migrator.process(:id=>id, :public_id=>"post_#{id}")
     end
     migrator.done
     pp [done.length, start]
-  end        
+  end
 end