cloudinary 1.9.1 → 1.20.0

data/cloudinary.gemspec

@@ -15,33 +15,40 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = "cloudinary"
 
-  s.files         = (`git ls-files`.split("\n") - `git ls-files samples`.split("\n")) + Dir.glob("vendor/assets/javascripts/*/*") + Dir.glob("vendor/assets/html/*")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.files         = `git ls-files`.split("\n").select { |f| !f.start_with?("test", "spec", "features", "samples") } + Dir.glob("vendor/assets/javascripts/*/*") + Dir.glob("vendor/assets/html/*")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
   s.add_dependency "aws_cf_signer"
-  s.add_development_dependency "rspec", '>=3.5'
-  s.add_development_dependency "rspec-rails"
-  s.add_development_dependency "rake"
 
-  if RUBY_VERSION > "2.0"
+  if RUBY_VERSION >= "2.0.0"
+    s.add_dependency "rest-client", ">= 2.0.0"
+  else
     s.add_dependency "rest-client"
-    s.add_development_dependency "actionpack"
-    s.add_development_dependency "simplecov"
-    s.add_development_dependency "rubyzip"
-  elsif RUBY_VERSION >= "1.9"
-    s.add_dependency "rest-client", '< 2.0'
-    s.add_dependency 'json', '~> 1.8'
-    s.add_development_dependency "actionpack", '< 5.0'
-    s.add_development_dependency "simplecov"
-    s.add_development_dependency "nokogiri", "<1.7.0"
-    s.add_development_dependency "rubyzip", '<1.2.1'
+  end
+
+  s.add_development_dependency "actionpack"
+  s.add_development_dependency "nokogiri"
+
+  if RUBY_VERSION >= "2.2.0"
+    s.add_development_dependency "rake", ">= 13.0.1"
   else
-    s.add_dependency "i18n", "<0.7.0"
-    s.add_dependency "rest-client", "<=1.6.8"
-    s.add_development_dependency "actionpack", "~>3.2.0"
-    s.add_development_dependency "nokogiri", "<1.6.0"
+    s.add_development_dependency "rake", "<= 12.2.1"
   end
 
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "rspec", '>=3.5'
+  s.add_development_dependency "rspec-retry"
+  s.add_development_dependency "rails", "~>5.2" if RUBY_VERSION >= "2.2.2"
+
+  s.add_development_dependency "railties", "<= 4.2.7" if RUBY_VERSION <= "1.9.3"
+  s.add_development_dependency "rspec-rails"
+
+  s.add_development_dependency "rubyzip"
+
+  if RUBY_VERSION <= "2.4.0"
+    s.add_development_dependency "simplecov", "<= 0.17.1" # support testing Ruby 1.9
+  else
+    s.add_development_dependency "simplecov", "> 0.18.0"
+  end
 end

data/lib/active_storage/blob_key.rb

@@ -0,0 +1,20 @@
+# Allow Blob attributes to be passed down to the service
+# attributes includes
+# - key - the string the BlobKey represents
+# - content_type
+# - filename
+module ActiveStorage
+  class BlobKey < String
+    attr_reader :attributes
+    def initialize(attributes)
+      if attributes.is_a? Hash
+        attributes.symbolize_keys!
+        super(attributes[:key])
+        @attributes = attributes
+      else
+        super(attributes)
+        @attributes = {key: attributes} if attributes
+      end
+    end
+  end
+end

data/lib/active_storage/service/cloudinary_service.rb

@@ -0,0 +1,249 @@
+require 'active_storage/blob_key'
+require 'cloudinary/helper'
+require 'net/http'
+
+unless ActiveStorage::Blob.method_defined? :original_key
+  class ActiveStorage::Blob
+    alias_method :original_key, :key
+
+    def key
+      original_key
+      ActiveStorage::BlobKey.new(@attributes.as_json)
+    end
+  end
+end
+
+module CloudinaryHelper
+  alias cloudinary_url_internal_original cloudinary_url_internal
+
+  def cloudinary_url_internal(source, options = {})
+    source = ActiveStorage::Blob.service.public_id(source) if defined? ActiveStorage::Blob.service.public_id
+    cloudinary_url_internal_original(source, options)
+  end
+end
+
+module ActiveStorage
+  class Service::CloudinaryService < Service
+    module Headers
+      CONTENT_TYPE = "Content-Type".freeze
+      CONTENT_MD5 = "Content-MD5".freeze
+    end
+    attr_reader :upload_options
+
+    def initialize(**options)
+      @options = options
+    end
+
+    def upload(key, io, filename: nil, checksum: nil, **options)
+      instrument :upload, key: key, checksum: checksum do
+        begin
+          extra_headers = checksum.nil? ? {} : {Headers::CONTENT_MD5 => checksum}
+          options = @options.merge(options)
+          Cloudinary::Uploader.upload(
+            io,
+            public_id: public_id_internal(key),
+            resource_type: resource_type(io, key),
+            context: {active_storage_key: key, checksum: checksum},
+            extra_headers: extra_headers,
+            **options
+          )
+        rescue CloudinaryException => e
+          raise ActiveStorage::IntegrityError, e.message, e.backtrace
+        end
+      end
+    end
+
+    def url(key, filename: nil, content_type: '', **options)
+      instrument :url, key: key do |payload|
+        url = Cloudinary::Utils.cloudinary_url(
+          public_id(key),
+          resource_type: resource_type(nil, key),
+          format: ext_for_file(key, filename, content_type),
+          **@options.merge(options.symbolize_keys)
+        )
+
+        payload[:url] = url
+
+        url
+      end
+    end
+
+    def url_for_direct_upload(key, **options)
+      instrument :url, key: key do |payload|
+        options = {:resource_type => resource_type(nil, key)}.merge(@options.merge(options.symbolize_keys))
+        options[:public_id] = public_id_internal(key)
+        # Provide file format for raw files, since js client does not include original file name.
+        #
+        # When the file is uploaded from the server, the request includes original filename. That allows Cloudinary
+        # to identify file extension and append it to the public id of the file (raw files include file extension
+        # in their public id, opposed to transformable assets (images/video) that use only basename). When uploading
+        # through direct upload (client side js), filename is missing, and that leads to inconsistent/broken URLs.
+        # To avoid that, we explicitly pass file format in options.
+        options[:format] = ext_for_file(key) if options[:resource_type] == "raw"
+        options[:context] = {active_storage_key: key}
+        options.delete(:file)
+        payload[:url] = api_uri("upload", options)
+      end
+    end
+
+    def headers_for_direct_upload(key, content_type:, checksum:, **)
+      {
+        Headers::CONTENT_TYPE => content_type,
+        Headers::CONTENT_MD5 => checksum,
+      }
+    end
+
+    def delete(key)
+      instrument :delete, key: key do
+        options = {
+          resource_type: resource_type(nil, key),
+          type: @options[:type]
+        }.compact
+
+        Cloudinary::Uploader.destroy public_id(key), **options
+      end
+    end
+
+    def delete_prefixed(prefix)
+      # This method is used by ActiveStorage to delete derived resources after the main resource was deleted.
+      # In Cloudinary, the derived resources are deleted automatically when the main resource is deleted.
+    end
+
+    def exist?(key)
+      instrument :exist, key: key do |payload|
+        begin
+          options = {
+            resource_type: resource_type(nil, key),
+            type: @options[:type]
+          }.compact
+
+          Cloudinary::Api.resource public_id(key), **options
+          true
+        rescue Cloudinary::Api::NotFound => e
+          false
+        end
+      end
+    end
+
+    def download(key, &block)
+      uri = URI(url(key))
+      if block_given?
+        instrument :streaming_download, key: key do
+          Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+            request = Net::HTTP::Get.new uri
+            http.request request do |response|
+              response.read_body &block
+            end
+          end
+        end
+      else
+        instrument :download, key: key do
+          res = Net::HTTP::get_response(uri)
+          res.body
+        end
+      end
+    end
+
+    # Return the partial content in the byte +range+ of the file at the +key+.
+    def download_chunk(key, range)
+      url = Cloudinary::Utils.unsigned_download_url(public_id(key), resource_type: resource_type(nil, key))
+      uri = URI(url)
+      instrument :download, key: key do
+        req = Net::HTTP::Get.new(uri)
+        range_end = case
+                    when range.end.nil? then ''
+                    when range.exclude_end? then range.end - 1
+                    else range.end
+                    end
+        req['range'] = "bytes=#{[range.begin, range_end].join('-')}"
+        res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+          http.request(req)
+        end
+        res.body.force_encoding(Encoding::BINARY)
+      end
+
+    end
+
+    def public_id(key)
+      return key unless @options[:folder]
+
+      File.join(@options.fetch(:folder), public_id_internal(key))
+    end
+
+    private
+
+    def api_uri(action, options)
+      base_url = Cloudinary::Utils.cloudinary_api_url(action, options)
+      upload_params = Cloudinary::Uploader.build_upload_params(options)
+
+      upload_params.reject! { |k, v| Cloudinary::Utils.safe_blank?(v) }
+      unless options[:unsigned]
+        upload_params = Cloudinary::Utils.sign_request(upload_params, options)
+      end
+      "#{base_url}?#{upload_params.to_query}"
+    end
+
+    # Helper method for getting the filename extension.
+    #
+    # It does the best effort when original filename does not include extension, but we know the mime-type.
+    #
+    # @param [ActiveStorage::BlobKey]   key          The blob key with attributes.
+    # @param [ActiveStorage::Filename]  filename     The original filename.
+    # @param [string]                   content_type The content type of the file.
+    #
+    # @return [string] The extension of the filename.
+    def ext_for_file(key, filename = nil, content_type = nil)
+      if filename.blank?
+        options = key.respond_to?(:attributes) ? key.attributes : {}
+        filename = ActiveStorage::Filename.new(options[:filename]) if options.has_key?(:filename)
+      end
+      ext = filename.respond_to?(:extension_without_delimiter) ? filename.extension_without_delimiter : nil
+
+      return ext unless ext.blank?
+
+      # Raw files are not convertible, no extension guessing for them
+      return nil if content_type_to_resource_type(content_type).eql?('raw')
+
+      # Fallback when there is no extension.
+      @formats ||= Hash.new do |h, key|
+        ext = Rack::Mime::MIME_TYPES.invert[key]
+        h[key] = ext.slice(1..-1) unless ext.nil?
+      end
+      @formats[content_type]
+    end
+
+    def public_id_internal(key)
+      # TODO: Allow custom manipulation of key to obscure how we store in Cloudinary
+      key
+    end
+
+    def content_type_to_resource_type(content_type)
+      return 'image' if content_type.nil?
+
+      type, subtype = content_type.split('/')
+      case type
+      when 'video', 'audio'
+        'video'
+      when 'text'
+        'raw'
+      when 'application'
+        case subtype
+        when 'pdf', 'postscript'
+          'image'
+        when 'vnd.apple.mpegurl', 'x-mpegurl', 'mpegurl' # m3u8
+          'video'
+        else
+          'raw'
+        end
+      else
+        'image'
+      end
+    end
+
+    def resource_type(io, key = "")
+      options = key.respond_to?(:attributes) ? key.attributes : {}
+      content_type = options[:content_type] || (io.nil? ? '' : Marcel::MimeType.for(io))
+      content_type_to_resource_type(content_type)
+    end
+  end
+end

data/lib/cloudinary.rb

@@ -16,7 +16,12 @@ require "cloudinary/missing"
 module Cloudinary
   autoload :Utils, 'cloudinary/utils'
   autoload :Uploader, 'cloudinary/uploader'
+  autoload :BaseConfig, "cloudinary/base_config"
+  autoload :Config, "cloudinary/config"
+  autoload :AccountConfig, "cloudinary/account_config"
+  autoload :BaseApi, "cloudinary/base_api"
   autoload :Api, "cloudinary/api"
+  autoload :AccountApi, "cloudinary/account_api"
   autoload :Downloader, "cloudinary/downloader"
   autoload :Blob, "cloudinary/blob"
   autoload :PreloadedFile, "cloudinary/preloaded_file"
@@ -29,8 +34,8 @@ module Cloudinary
   OLD_AKAMAI_SHARED_CDN = "cloudinary-a.akamaihd.net"
   SHARED_CDN            = AKAMAI_SHARED_CDN
 
-  USER_AGENT      = "CloudinaryRuby/" + VERSION
-  @@user_platform = ""
+  USER_AGENT      = "CloudinaryRuby/#{VERSION} (Ruby #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL})"
+  @@user_platform = defined?(Rails.version) ? "Rails/#{Rails.version}" : ""
 
   # Add platform information to the USER_AGENT header
   # This is intended for platform information and not individual applications!
@@ -44,7 +49,7 @@ module Cloudinary
 
   def self.USER_AGENT
     if @@user_platform.empty?
-      "#{USER_AGENT}"
+      USER_AGENT
     else
       "#{@@user_platform} #{USER_AGENT}"
     end
@@ -58,71 +63,42 @@ module Cloudinary
     "ept"  => "eps"
   }
 
-  @@config = nil
-
+  # Cloudinary config
+  #
+  # @param [Hash] new_config If +new_config+ is passed, Config will be updated with it
+  # @yieldparam [OpenStruct] Config can be updated in the block
+  #
+  # @return [OpenStruct]
   def self.config(new_config=nil)
-    first_time = @@config.nil?
-    @@config   ||= OpenStruct.new((YAML.load(ERB.new(IO.read(config_dir.join("cloudinary.yml"))).result)[config_env] rescue {}))
-
-    # Heroku support
-    if first_time && ENV["CLOUDINARY_CLOUD_NAME"]
-      set_config(
-        "cloud_name"          => ENV["CLOUDINARY_CLOUD_NAME"],
-        "api_key"             => ENV["CLOUDINARY_API_KEY"],
-        "api_secret"          => ENV["CLOUDINARY_API_SECRET"],
-        "secure_distribution" => ENV["CLOUDINARY_SECURE_DISTRIBUTION"],
-        "private_cdn"         => ENV["CLOUDINARY_PRIVATE_CDN"].to_s == 'true',
-        "secure"              => ENV["CLOUDINARY_SECURE"].to_s == 'true'
-      )
-    elsif first_time && ENV["CLOUDINARY_URL"]
-      config_from_url(ENV["CLOUDINARY_URL"])
-    end
+    @@config ||= make_new_config(Config)
 
-    set_config(new_config) if new_config
-    yield(@@config) if block_given?
+    @@config.update(new_config) if new_config
+    yield @@config if block_given?
 
     @@config
   end
 
-  def self.config_from_url(url)
-    @@config ||= OpenStruct.new
-    uri      = URI.parse(url)
-    set_config(
-      "cloud_name"          => uri.host,
-      "api_key"             => uri.user,
-      "api_secret"          => uri.password,
-      "private_cdn"         => !uri.path.blank?,
-      "secure_distribution" => uri.path[1..-1]
-    )
-    uri.query.to_s.split("&").each do
-    |param|
-      key, value = param.split("=")
-      if isNestedKey? key
-        putNestedKey key, value
-      else
-        set_config(key => URI.decode(value))
-      end
-    end
-  end
+  # Cloudinary account config
+  #
+  # @param [Hash] new_config If +new_config+ is passed, Account Config will be updated with it
+  # @yieldparam [OpenStruct] Account config can be updated in the block
+  #
+  # @return [OpenStruct]
+  def self.account_config(new_config=nil)
+    @@account_config ||= make_new_config(AccountConfig)
 
-  def self.putNestedKey(key, value)
-    chain   = key.split(/[\[\]]+/).reject { |i| i.empty? }
-    outer   = @@config
-    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
+    @@account_config.update(new_config) if new_config
+    yield @@account_config if block_given?
+
+    @@account_config
   end
 
+  def self.config_from_url(url)
+    config.load_from_url(url)
+  end
 
-  def self.isNestedKey?(key)
-    /\w+\[\w+\]/ =~ key
+  def self.config_from_account_url(url)
+    account_config.load_from_url(url)
   end
 
   def self.app_root
@@ -135,25 +111,39 @@ module Cloudinary
   end
 
   private
-  
+
   def self.config_env
     return ENV["CLOUDINARY_ENV"] if ENV["CLOUDINARY_ENV"]
     return Rails.env if defined? Rails::env
     nil
   end
-  
+
   def self.config_dir
-    return Pathname.new(ENV["CLOUDINARY_CONFIG_DIR"]) if ENV["CLOUDINARY_CONFIG_DIR"] 
+    return Pathname.new(ENV["CLOUDINARY_CONFIG_DIR"]) if ENV["CLOUDINARY_CONFIG_DIR"]
     self.app_root.join("config")
   end
-  
+
   def self.set_config(new_config)
     new_config.each{|k,v| @@config.send(:"#{k}=", v) if !v.nil?}
   end
+
+  # Builds config from yaml file, extends it with specific module and loads configuration from environment variable
+  #
+  # @param [Module] config_module Config is extended with this module after being built
+  #
+  # @return [OpenStruct]
+  def self.make_new_config(config_module)
+    OpenStruct.new((YAML.load(ERB.new(IO.read(config_dir.join("cloudinary.yml"))).result)[config_env] rescue {})).tap do |config|
+      config.extend(config_module)
+      config.load_config_from_env
+    end
+  end
+
+  private_class_method :make_new_config
 end
   # Prevent require loop if included after Rails is already initialized.
   require "cloudinary/helper" if defined?(::ActionView::Base)
-  require "cloudinary/controller" if defined?(::ActionController::Base)
+  require "cloudinary/cloudinary_controller" if defined?(::ActionController::Base)
   require "cloudinary/railtie" if defined?(Rails) && defined?(Rails::Railtie)
   require "cloudinary/engine" if defined?(Rails) && defined?(Rails::Engine)