cloudinary 1.9.1 → 1.20.0

data/lib/cloudinary/auth_token.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'openssl'
 if RUBY_VERSION > "2"
   require "ostruct"
@@ -10,6 +12,7 @@ module Cloudinary
   module AuthToken
     SEPARATOR = '~'
     UNSAFE = /[ "#%&\'\/:;<=>?@\[\\\]^`{\|}~]/
+    EMPTY_TOKEN = {}.freeze
 
     def self.generate(options = {})
       key = options[:key]
@@ -30,6 +33,10 @@ module Cloudinary
         end
       end
 
+      if url.blank? && acl.blank?
+        raise 'AuthToken must contain either an acl or a url property'
+      end
+
       token = []
       token << "ip=#{ip}" if ip
       token << "st=#{start}" if start
@@ -42,12 +49,11 @@ module Cloudinary
       "#{name}=#{token.join(SEPARATOR)}"
     end
 
-
     # Merge token2 to token1 returning a new
     # Requires to support Ruby 1.9
     def self.merge_auth_token(token1, token2)
-      token1 = token1 || {}
-      token2 = token2 || {}
+      token1 = token1 || EMPTY_TOKEN
+      token2 = token2 || EMPTY_TOKEN
       token1 = token1.respond_to?( :to_h) ? token1.to_h : token1
       token2 = token2.respond_to?( :to_h) ? token2.to_h : token2
       token1.merge(token2)
@@ -69,4 +75,4 @@ module Cloudinary
       OpenSSL::HMAC.hexdigest(digest, bin_key, message)
     end
   end
-end
+end

data/lib/cloudinary/base_api.rb

@@ -0,0 +1,79 @@
+require "rest_client"
+require "json"
+
+module Cloudinary::BaseApi
+  class Error < CloudinaryException; end
+  class NotFound < Error; end
+  class NotAllowed < Error; end
+  class AlreadyExists < Error; end
+  class RateLimited < Error; end
+  class BadRequest < Error; end
+  class GeneralError < Error; end
+  class AuthorizationRequired < Error; end
+
+  class Response < Hash
+    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
+
+        @rate_limit_allowed   = response.headers[:x_featureratelimit_limit].to_i if response.headers[:x_featureratelimit_limit]
+        @rate_limit_reset_at  = Time.parse(response.headers[:x_featureratelimit_reset]) if response.headers[:x_featureratelimit_reset]
+        @rate_limit_remaining = response.headers[:x_featureratelimit_remaining].to_i if response.headers[:x_featureratelimit_remaining]
+      end
+    end
+  end
+
+  def self.extended(base)
+    [Error, NotFound, NotAllowed, AlreadyExists, RateLimited, BadRequest, GeneralError, AuthorizationRequired, Response].each do |constant|
+      base.const_set(constant.name.split("::").last, constant)
+    end
+  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"])
+    end
+  end
+
+  private
+
+  def call_cloudinary_api(method, uri, user, password, params, options, &api_url_builder)
+    cloudinary = options[:upload_prefix] || Cloudinary.config.upload_prefix || 'https://api.cloudinary.com'
+    api_url    = Cloudinary::Utils.smart_escape(api_url_builder.call(cloudinary, uri).flatten.join('/'))
+    timeout    = options[:timeout] || Cloudinary.config.timeout || 60
+    proxy      = options[:api_proxy] || Cloudinary.config.api_proxy
+
+    headers = { "User-Agent" => Cloudinary::USER_AGENT }
+
+    if options[:content_type] == :json
+      payload = params.to_json
+      headers.merge!("Content-Type" => "application/json", "Accept" => "application/json")
+    else
+      payload = params.reject { |_, v| v.nil? || v == "" }
+    end
+
+    call_json_api(method, api_url, payload, timeout, headers, proxy, user, password)
+  end
+end

data/lib/cloudinary/base_config.rb

@@ -0,0 +1,70 @@
+module Cloudinary
+  module BaseConfig
+    def load_from_url(url)
+      return unless url && !url.empty?
+
+      parsed_url = URI.parse(url)
+      scheme = parsed_url.scheme.to_s.downcase
+
+      if expected_scheme != scheme
+        raise(CloudinaryException,
+              "Invalid #{env_url} scheme. Expecting to start with '#{expected_scheme}://'")
+      end
+
+      update(config_from_parsed_url(parsed_url))
+      setup_from_parsed_url(parsed_url)
+    end
+
+    def update(new_config = {})
+      new_config.each{ |k,v| public_send(:"#{k}=", v) unless v.nil?}
+    end
+
+    def load_config_from_env
+      raise NotImplementedError
+    end
+
+    private
+
+    def config_from_parsed_url(parsed_url)
+      raise NotImplementedError
+    end
+
+    def env_url
+      raise NotImplementedError
+    end
+
+    def expected_scheme
+      raise NotImplementedError
+    end
+
+    def put_nested_key(key, value)
+      chain   = key.split(/[\[\]]+/).reject(&:empty?)
+      outer   = self
+      lastKey = chain.pop
+      chain.each do |innerKey|
+        inner = outer[innerKey]
+        if inner.nil?
+          inner           = OpenStruct.new
+          outer[innerKey] = inner
+        end
+        outer = inner
+      end
+      outer[lastKey] = value
+    end
+
+    def is_nested_key?(key)
+      /\w+\[\w+\]/ =~ key
+    end
+
+    def setup_from_parsed_url(parsed_url)
+      parsed_url.query.to_s.split("&").each do |param|
+        key, value = param.split("=")
+        if is_nested_key? key
+          put_nested_key key, value
+        else
+          update(key => Utils.smart_unescape(value))
+        end
+      end
+    end
+  end
+end

data/lib/cloudinary/cache.rb

@@ -0,0 +1,38 @@
+require 'digest'
+
+module Cloudinary
+  module Cache
+
+    class << self
+      attr_accessor :storage
+
+      def get(public_id, options)
+        if block_given?
+          storage.read(generate_cache_key(public_id, options)) {yield}
+        else
+          storage.read(generate_cache_key(public_id, options))
+        end
+      end
+
+      def set(public_id, options, value)
+        storage.write(generate_cache_key(public_id, options), value)
+      end
+
+      alias_method :fetch, :get
+
+      def flush_all
+        storage.clear
+      end
+
+      private
+
+      def generate_cache_key(public_id, options)
+        type = options[:type] || "upload"
+        resource_type = options[:resource_type] || "image"
+        transformation = Cloudinary::Utils.generate_transformation_string options.clone
+        format = options[:format]
+        Digest::SHA1.hexdigest [public_id, type, resource_type, transformation, format].reject(&:blank?).join('/')
+      end
+    end
+  end
+end

data/lib/cloudinary/cache/breakpoints_cache.rb

@@ -0,0 +1,31 @@
+module Cloudinary::Cache
+  class BreakpointsCache
+    attr_accessor :adapter
+
+    def set(public_id, options, value)
+      upload_type, resource_type, transformation, format = options_to_parameters(options)
+      @adapter.set(public_id, upload_type, resource_type, transformation, format, value)
+
+    end
+
+    def fetch(public_id, options)
+      upload_type, resource_type, transformation, format = options_to_parameters(options)
+      @adapter.set(public_id, upload_type, resource_type, transformation, format, &Proc.new)
+
+    end
+
+    def get(public_id, options)
+      upload_type, resource_type, transformation, format = options_to_parameters(options)
+      @adapter.get(public_id, upload_type, resource_type, transformation, format)
+    end
+
+    def options_to_parameters(options)
+      options = Cloudinary::Utils.symbolize_keys options
+      transformation = Cloudinary::Utils.generate_transformation_string(options)
+      upload_type = options[:type] || 'upload'
+      resource_type = options[:resource_type] || 'image'
+      format = options[:format] || ""
+      [upload_type, resource_type, transformation, format]
+    end
+  end
+end

data/lib/cloudinary/cache/key_value_cache_adapter.rb

@@ -0,0 +1,25 @@
+require 'digest'
+module Cloudinary::Cache
+  class KeyValueCacheAdapter < CacheAdapter
+    def get(public_id, type, resource_type, transformation, format)
+      key = generate_cache_key(public_id, type, resource_type, transformation, format)
+      @storage.get(key)
+    end
+
+    def set(public_id, type, resource_type, transformation, format, value)
+      key = generate_cache_key(public_id, type, resource_type, transformation, format)
+      @storage.set(key, value)
+    end
+
+    def flush_all()
+      @storage.flush_all()
+    end
+
+    private
+
+    def generate_cache_key(public_id, type, resource_type, transformation, format)
+      Digest::SHA1.hexdigest [public_id, type, resource_type, transformation, format].reject(&:blank?)
+    end
+
+  end
+end

data/lib/cloudinary/cache/rails_cache_adapter.rb

@@ -0,0 +1,34 @@
+module Cloudinary::Cache
+  class RailsCacheAdapter < CacheAdapter
+
+    def flush_all
+    end
+
+    def get(public_id, type, resource_type, transformation, format)
+      key = generate_cache_key(public_id, type, resource_type, transformation, format)
+      Rails.cache.read(key)
+    end
+
+    def init
+      unless defined? Rails
+        raise CloudinaryException.new "Rails is required in order to use RailsCacheAdapter"
+      end
+    end
+
+    def set(public_id, type, resource_type, transformation, format, value)
+      key = generate_cache_key(public_id, type, resource_type, transformation, format)
+      Rails.cache.write(key, value)
+    end
+
+    def fetch(public_id, type, resource_type, transformation, format)
+      key = generate_cache_key(public_id, type, resource_type, transformation, format)
+      Rails.cache.fetch(key, &Proc.new)
+    end
+    private
+
+    def generate_cache_key(public_id, type, resource_type, transformation, format)
+      Digest::SHA1.hexdigest [public_id, type, resource_type, transformation, format].reject(&:blank?)
+    end
+
+  end
+end

data/lib/cloudinary/cache/storage/rails_cache_storage.rb

@@ -0,0 +1,5 @@
+module Cloudinary::Cache::Storage
+  class RailsCacheStorage
+
+  end
+end

data/lib/cloudinary/carrier_wave.rb

@@ -3,14 +3,16 @@ require 'cloudinary/carrier_wave/process'
 require 'cloudinary/carrier_wave/error'
 require 'cloudinary/carrier_wave/remote'
 require 'cloudinary/carrier_wave/preloaded'
-require 'cloudinary/carrier_wave/storage'
+require 'cloudinary/carrier_wave/storage' if defined?(::CarrierWave) # HACK
 
 module Cloudinary::CarrierWave
 
   def self.included(base)
     base.storage Cloudinary::CarrierWave::Storage
+    base.cache_storage = :file if base.cache_storage.blank?
     base.extend ClassMethods
-    base.class_attribute :storage_type, :metadata
+    base.class_attribute :metadata
+    base.class_attribute :storage_type, instance_reader: false
     override_in_versions(base, :blank?, :full_public_id, :my_public_id, :all_versions_processors, :stored_version)
   end
 

data/lib/cloudinary/carrier_wave/remote.rb

@@ -1,10 +1,11 @@
 module Cloudinary::CarrierWave
   def download!(uri, *args)
-    return super if !self.cloudinary_should_handle_remote?
+    return super unless self.cloudinary_should_handle_remote?
     if respond_to?(:process_uri)
       uri = process_uri(uri)
     else # Backward compatibility with old CarrierWave
-      uri = URI.parse(URI.escape(URI.unescape(uri)))
+      remote_url_unsafe_chars = /([^a-zA-Z0-9_.\-\/:?&=]+)/ # In addition allow query string characters: "?","&" and "="
+      uri = URI.parse(Cloudinary::Utils.smart_escape(Cloudinary::Utils.smart_unescape(uri), remote_url_unsafe_chars))
     end
     return if uri.to_s.blank?
     self.original_filename = @cache_id = @filename = File.basename(uri.path).gsub(/[^a-zA-Z0-9\.\-\+_]/, '')

data/lib/cloudinary/carrier_wave/storage.rb

@@ -1,7 +1,8 @@
 class Cloudinary::CarrierWave::Storage < ::CarrierWave::Storage::Abstract
 
   def store!(file)
-    return if !uploader.enable_processing
+    return unless uploader.enable_processing
+
     if uploader.is_main_uploader?
       case file
       when Cloudinary::CarrierWave::PreloadedCloudinaryFile

data/lib/cloudinary/{controller.rb → cloudinary_controller.rb}

@@ -1,13 +1,11 @@
-module CloudinaryController
+module Cloudinary::CloudinaryController
   protected
-  
+
   def valid_cloudinary_response?
     received_signature = request.query_parameters[:signature]
     calculated_signature = Cloudinary::Utils.api_sign_request(
       request.query_parameters.select{|key, value| [:public_id, :version].include?(key.to_sym)},
       Cloudinary.config.api_secret)
     return received_signature == calculated_signature
-  end  
+  end
 end
-
-ActionController::Base.send :include, CloudinaryController

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