cloudinary 1.9.1 → 1.10.0

checksums.yaml

@@ -1,7 +1,17 @@
 ---
-SHA1:
-  metadata.gz: aa2967c1b17b93efadf7db793ac1110b7bd411f6
-  data.tar.gz: 79d2beeae5fe07afd1c4aaffb3bc17d442b2f418
+!binary "U0hBMjU2":
+  metadata.gz: !binary |-
+    ODI0YWQ0Mjg5NGRkYjkxYjRkZTNkOTZhMTgzNzA5YmMyY2E2ZGVhMmZmN2Fj
+    NDRkYTNkNjI3ZDM5YjEwZDFkYg==
+  data.tar.gz: !binary |-
+    MGMyNDU5NTIxY2Q3M2UyMWM2ZjFmYWVkZjUwNGZmYWFmNmE0MWY0MWY2MTgz
+    ZTgyNzIyMjA0YjU1NjZhMWM3Yg==
 SHA512:
-  metadata.gz: a46e2e84655389ac281378a44212964acd0f43f0ff66b9d7ef6fc0ce5cbf8a6b6467925dca57768174f0246780f844d6f4f08683fac95d46a49d3bee1d3ec18b
-  data.tar.gz: 873cf3dbb2ad9296c31d0aacfbbacf66b210bad3220c73e27014f7c386295cad91ae1347fd4c4d5c1631d311bc88c8fe899404bc68aa91a6e12f37e7346028f5
+  metadata.gz: !binary |-
+    YWViMTg1MzFiOWI1ODkzYWYzNWQxMzUyZWUyMTUyNWIwODRiMDI5NWFjNmYy
+    YjVlNjc3NjUzN2E3ODgzNWRiNTEwZDVlZWFlYWQ2ODg5NTc3ZTcxNzIyOThl
+    YWY3MjlkYzkwNjk0MDY1YjI3ODJjM2RjY2FiMWYyOTMyODU4NzU=
+  data.tar.gz: !binary |-
+    MTQzOWE0OGZjZTg3MmI1YTJiOWQ2NzI1MmE4ZDQ2YWQxN2NhMThmMjMzNjJk
+    ZjUwZjNmYTc4MDA4ODBlM2Y0Y2FjOWNiOTc2NjI1YTg1M2EyOTg1MTNkMjg1
+    NTE2ZmQ2ZGEyMjk2YTE1MDM0NWM3ZGIyZDcxZDFjM2ZlNDJhNTk=

data/.gitignore

@@ -54,4 +54,5 @@ bower.json
 # Ignore pow environment settings
 .powenv
 
+!lib/
 cloudinary.yml

data/CHANGELOG.md

@@ -1,4 +1,36 @@
 
+1.10.0 / 2018-11-08
+===================
+
+New functionality and features
+------------------------------
+
+  * Add the `custom_function` transformation parameter
+  * Add Picture and source tags
+  * Add `srcset` attribute to image tag
+  * Add support for overlays of type fetch
+  * Add breakpoints cache
+
+Other Changes
+-------------
+
+  * Add `update_version` script
+  * Fix transformations test
+  * Replace ruby list notation to support older ruby versions
+  * Refactor tests
+  * Replace REXML  with Nokogiri
+  * Un-ignore the lib folder
+  * Ignore empty transformations when processing an array of transformations
+  * Restore configuration after each test
+  * Limit Rack version to fix compatibility issues with ruby 1.9.3
+  * Fix context escaping in call_context_api
+  * Fix uploadLarge to use X-Unique-Upload-Id
+  * Add test cases of OCR for upload and URL generation
+  * Add test case of conditional tags
+  * Fix expected result in cname with cdn_subdomain test
+  * Fix raw conversion test
+  * Raise exception when api-secret is missing in signed-url flow
+
 1.9.1 / 2018-03-06
 ==================
 

data/cloudinary.gemspec

@@ -33,10 +33,11 @@ Gem::Specification.new do |s|
   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 "actionpack", '<5.0'
     s.add_development_dependency "simplecov"
     s.add_development_dependency "nokogiri", "<1.7.0"
     s.add_development_dependency "rubyzip", '<1.2.1'
+    s.add_development_dependency "rack", '<1.6.5'
   else
     s.add_dependency "i18n", "<0.7.0"
     s.add_dependency "rest-client", "<=1.6.8"

data/lib/cloudinary/api.rb

@@ -19,9 +19,9 @@ class Cloudinary::Api
         # 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
-        @rate_limit_reset_at  = Time.parse(response.headers[:x_featureratelimit_reset])
-        @rate_limit_remaining = response.headers[:x_featureratelimit_remaining].to_i
+        @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
@@ -311,6 +311,18 @@ class Cloudinary::Api
       update_resources_access_mode(access_mode, :public_ids, public_ids, options)
   end
 
+  def self.get_breakpoints(public_id, options)
+    local_options = options.clone
+    base_transformation = Cloudinary::Utils.generate_transformation_string(local_options)
+    srcset = local_options[:srcset]
+    breakpoints = [:min_width, :max_width, :bytes_step, :max_images].map {|k| srcset[k]}.join('_')
+
+
+    local_options[:transformation] = [base_transformation, width: "auto:breakpoints_#{breakpoints}:json"]
+    json_url = Cloudinary::Utils.cloudinary_url public_id, local_options
+    call_json_api('GET', json_url, {}, 60, {})
+  end
+
   protected
 
   def self.call_api(method, uri, params, options)
@@ -330,24 +342,27 @@ class Cloudinary::Api
     else
       payload = params.reject { |k, v| v.nil? || v=="" }
     end
+    call_json_api(method, api_url, payload, timeout, headers)
+  end
+
+  def self.call_json_api(method, api_url, payload, timeout, headers)
     RestClient::Request.execute(:method => method, :url => api_url, :payload => payload, :timeout => timeout, :headers => headers) do
     |response, request, tmpresult|
       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
+                        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 = parse_json_response(response)
       raise exception_class.new(json["error"]["message"])
     end
   end
-
   def self.parse_json_response(response)
     return Cloudinary::Utils.json_decode(response.body)
   rescue => e

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/helper.rb

@@ -1,7 +1,11 @@
 require 'digest/md5'
 require 'cloudinary/video_helper'
+require 'cloudinary/responsive'
 
 module CloudinaryHelper
+  include ActionView::Helpers::CaptureHelper
+  include Responsive
+
   CL_BLANK = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7"
 
   # Stand-in for Rails image_tag helper that accepts various options for transformations.
@@ -37,13 +41,45 @@ module CloudinaryHelper
 
   end
 
+
+  def cl_picture_tag(source, options = {}, sources =[])
+
+    options = options.clone
+    content_tag 'picture' do
+      sources.map do |source_def|
+        source_options = options.clone
+        source_options = Cloudinary::Utils.chain_transformation(source_options, source_def[:transformation])
+        source_options[:media] = source_def
+        cl_source_tag(source, source_options)
+      end.push(cl_image_tag(source, options))
+          .join('')
+          .html_safe
+    end
+  end
+
+  def cl_source_tag(source, options)
+    srcset_param = options.fetch(:srcset, {}).merge(Cloudinary.config.srcset || {})
+    attributes = options.fetch(:attributes, {}).clone
+    responsive_attributes = generate_image_responsive_attributes(source, attributes, srcset_param, options)
+    attributes = attributes.merge(responsive_attributes)
+    unless attributes.has_key? :srcset
+      attributes[:srcset] = Cloudinary::Utils.cloudinary_url(source, options)
+    end
+    media_attr = generate_media_attribute(options[:media])
+    attributes[:media] = media_attr unless media_attr.empty?
+    tag "source", attributes, true
+  end
+
+
   def cloudinary_tag(source, options = {})
     tag_options = options.clone
     tag_options[:width] = tag_options.delete(:html_width) if tag_options.include?(:html_width)
     tag_options[:height] = tag_options.delete(:html_height) if tag_options.include?(:html_height)
     tag_options[:size] = tag_options.delete(:html_size) if tag_options.include?(:html_size)
     tag_options[:border] = tag_options.delete(:html_border) if tag_options.include?(:html_border)
-    source = cloudinary_url_internal(source, tag_options)
+    srcset_param = Cloudinary::Utils.config_option_consume(tag_options, :srcset, {})
+    src = cloudinary_url_internal(source, tag_options)
+    attributes = tag_options.delete(:attributes) || {}
 
     responsive_placeholder = Cloudinary::Utils.config_option_consume(tag_options, :responsive_placeholder)
     client_hints = Cloudinary::Utils.config_option_consume(tag_options, :client_hints)
@@ -51,15 +87,21 @@ module CloudinaryHelper
     hidpi = tag_options.delete(:hidpi)
     responsive = tag_options.delete(:responsive)
     if !client_hints && (hidpi || responsive)
-      tag_options["data-src"] = source
-      source = nil
+      tag_options["data-src"] = src
+      src = nil
       extra_class = responsive ? "cld-responsive" : "cld-hidpi"
       tag_options[:class] = [tag_options[:class], extra_class].compact.join(" ")
       responsive_placeholder = CL_BLANK if responsive_placeholder == "blank"
       tag_options[:src] = responsive_placeholder
     end
+    responsive_attrs = generate_image_responsive_attributes(source, attributes, srcset_param, options)
+    unless  responsive_attrs.empty?
+      tag_options.delete(:width)
+      tag_options.delete(:height)
+      tag_options.merge! responsive_attrs
+    end
     if block_given?
-      yield(source,tag_options)
+      yield(src,tag_options)
     else
       tag('div', tag_options)
     end
@@ -281,6 +323,7 @@ module CloudinaryHelper
   end
 
   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)

data/lib/cloudinary/responsive.rb

@@ -0,0 +1,111 @@
+module Responsive
+  # Calculate breakpoints for the given configuration
+  # @private
+  def generate_breakpoints(srcset)
+    return srcset[:breakpoints] if srcset[:breakpoints].is_a? Array
+    min_width, max_width, max_images = [:min_width, :max_width, :max_images].map {|k| srcset[k]}
+    unless [min_width, max_width, max_images].all? {|a| a.is_a? Numeric}
+      throw 'Either (min_width, max_width, max_images) or breakpoints must be provided to the image srcset attribute'
+    end
+    if min_width > max_width
+      throw 'min_width must be less than max_width'
+    end
+
+    if max_images <= 0
+      throw 'max_images must be a positive integer'
+    elsif max_images === 1
+      min_width = max_width
+    end
+    step_size = ((max_width - min_width).to_f / [max_images - 1, 1].max).ceil
+    current = min_width
+    breakpoints = []
+    while current < max_width do
+      breakpoints.push(current)
+      current += step_size
+    end
+    breakpoints.push(max_width)
+  end
+
+  # Generate the srcset and sizes attributes
+  # @private
+  def generate_image_responsive_attributes(public_id, attributes = {}, srcset_data = {}, options = {})
+    # Create both srcset and sizes here to avoid fetching breakpoints twice
+
+    responsive_attributes = {}
+    generate_srcset = !attributes[:srcset]
+
+    if srcset_data.empty?
+      return responsive_attributes
+    elsif srcset_data.is_a? String
+      responsive_attributes[:srcset] = srcset_data
+      return responsive_attributes
+    end
+
+    generate_sizes = !attributes[:sizes] && srcset_data[:sizes]
+
+    if generate_srcset || generate_sizes
+      breakpoints = get_or_generate_breakpoints(public_id, srcset_data, options)
+
+      if generate_srcset
+        transformation = srcset_data[:transformation]
+        srcset_attr = generate_srcset_attribute(public_id, breakpoints, transformation, options)
+        responsive_attributes[:srcset] = srcset_attr unless srcset_attr.empty?
+      end
+
+      if generate_sizes
+        sizes_attr = generate_sizes_attribute(breakpoints)
+        responsive_attributes[:sizes] = sizes_attr unless sizes_attr.empty?
+      end
+    end
+
+    responsive_attributes
+  end
+
+  # If cache is enabled, get the breakpoints from the cache. If the values were not found in the cache,
+  # or cache is not enabled, generate the values.
+  # @private
+  def get_or_generate_breakpoints(public_id, srcset, options)
+    if srcset[:use_cache]
+      Cloudinary::Cache.get(public_id, options) || []
+    else
+      generate_breakpoints(srcset)
+    end
+  end
+
+  # Generate a resource URL scaled to the given width
+  # @private
+  def generate_scaled_url(public_id, width, transformation={}, options={})
+    config_params = Cloudinary::Utils.extract_config_params(options)
+    transformation ||= options
+    config_params[:raw_transformation] = Cloudinary::Utils.generate_transformation_string(
+        [transformation.clone, {:crop => 'scale', :width => width}].reject(&:blank?))
+    config_params.delete :width
+    config_params.delete :height
+    Cloudinary::Utils.cloudinary_url public_id, config_params
+  end
+
+  # Generate srcset attribute value of the HTML img tag
+  # @private
+  def generate_srcset_attribute(public_id, breakpoints, transformation={}, options={})
+    options = options.clone
+    Cloudinary::Utils.patch_fetch_format(options)
+    breakpoints.map{|width| "#{generate_scaled_url(public_id, width, transformation, options)} #{width}w"}.join(', ').html_safe
+  end
+
+  # Generate media attribute value of the HTML img tag
+  # @private
+  def generate_media_attribute(options)
+    options ||= {}
+    [:min_width, :max_width]
+      .select {|name| options[name]}
+      .map {|name| "(#{name.to_s.tr('_', '-')}: #{options[name]}px)"}
+      .join(' and ').html_safe
+  end
+
+
+  # Generate the sizes attribute
+  # @private
+  def generate_sizes_attribute(breakpoints)
+    breakpoints.map{|width| "(max-width: #{width}px) #{width}px"}.join(', ')
+  end
+end