cloudinary 1.9.1 → 1.10.0

data/lib/cloudinary/uploader.rb

@@ -1,6 +1,7 @@
 # Copyright Cloudinary
 require 'rest_client'
 require 'json'
+require 'cloudinary/cache'
 
 class Cloudinary::Uploader
 
@@ -100,6 +101,7 @@ class Cloudinary::Uploader
     else
       filename = "cloudinaryfile"
     end
+    unique_upload_id = Cloudinary::Utils.random_public_id
     upload     = nil
     index      = 0
     chunk_size = options[:chunk_size] || 20_000_000
@@ -107,8 +109,7 @@ class Cloudinary::Uploader
       buffer      = file.read(chunk_size)
       current_loc = index*chunk_size
       range       = "bytes #{current_loc}-#{current_loc+buffer.size - 1}/#{file.size}"
-      upload      = upload_large_part(Cloudinary::Blob.new(buffer, :original_filename => filename), options.merge(:public_id => public_id, :content_range => range))
-      public_id   = upload["public_id"]
+      upload      = upload_large_part(Cloudinary::Blob.new(buffer, :original_filename => filename), options.merge(:public_id => public_id, :unique_upload_id => unique_upload_id, :content_range => range))
       index       += 1
     end
     upload
@@ -292,7 +293,7 @@ class Cloudinary::Uploader
     return call_api("context", options) do
       {
         :timestamp  => (options[:timestamp] || Time.now.to_i),
-        :context    => Cloudinary::Utils.encode_hash(context),
+        :context    => Cloudinary::Utils.encode_context(context),
         :public_ids => Cloudinary::Utils.build_array(public_ids),
         :command    => command,
         :type       => options[:type]
@@ -303,6 +304,7 @@ class Cloudinary::Uploader
   def self.call_api(action, options)
     options      = options.clone
     return_error = options.delete(:return_error)
+    use_cache = options[:use_cache] || Cloudinary.config.use_cache
 
     params, non_signable = yield
     non_signable         ||= []
@@ -320,6 +322,7 @@ class Cloudinary::Uploader
     api_url                  = Cloudinary::Utils.cloudinary_api_url(action, options)
     headers                  = { "User-Agent" => Cloudinary::USER_AGENT }
     headers['Content-Range'] = options[:content_range] if options[:content_range]
+    headers['X-Unique-Upload-Id'] = options[:unique_upload_id] if options[:unique_upload_id]
     headers.merge!(options[:extra_headers]) if options[:extra_headers]
     RestClient::Request.execute(:method => :post, :url => api_url, :payload => params.reject { |k, v| v.nil? || v=="" }, :timeout => timeout, :headers => headers) do
     |response, request, tmpresult|
@@ -338,11 +341,26 @@ class Cloudinary::Uploader
         end
       end
     end
-
+    if use_cache && !result.nil?
+      cache_results(result)
+    end
     result
   end
 
   def self.build_custom_headers(headers)
     Array(headers).map { |*a| a.join(": ") }.join("\n")
   end
+
+  def self.cache_results(result)
+      if result["responsive_breakpoints"]
+        result["responsive_breakpoints"].each do |bp|
+          Cloudinary::Cache.set(
+            result["public_id"],
+            {type: result["type"], resource_type: result["resource_type"], raw_transformation: bp["transformation"]},
+            bp["breakpoints"].map{|o| o['width']}
+          )
+          end
+      end
+
+      end
 end

data/lib/cloudinary/utils.rb

@@ -6,6 +6,7 @@ require 'aws_cf_signer'
 require 'json'
 require 'cgi'
 require 'cloudinary/auth_token'
+require 'cloudinary/responsive'
 
 class Cloudinary::Utils
   # @deprecated Use Cloudinary::SHARED_CDN
@@ -40,13 +41,100 @@ class Cloudinary::Utils
     "tags"                 => "tags",
     "width"                => "w"
   }
+
+  URL_KEYS = %w[
+      api_secret
+      auth_token
+      cdn_subdomain
+      cloud_name
+      cname
+      format
+      private_cdn
+      resource_type
+      secure
+      secure_cdn_subdomain
+      secure_distribution
+      shorten
+      sign_url
+      ssl_detected
+      type
+      url_suffix
+      use_root_path
+      version
+  ].map(&:to_sym)
+
+
+  TRANSFORMATION_PARAMS = %w[
+      angle
+      aspect_ratio
+      audio_codec
+      audio_frequency
+      background
+      bit_rate
+      border
+      color
+      color_space
+      crop
+      custom_function
+      default_image
+      delay
+      density
+      dpr
+      duration
+      effect
+      end_offset
+      fetch_format
+      flags
+      gravity
+      height
+      if
+      keyframe_interval
+      offset
+      opacity
+      overlay
+      page
+      prefix
+      quality
+      radius
+      raw_transformation
+      responsive_width
+      size
+      start_offset
+      streaming_profile
+      transformation
+      underlay
+      variables
+      video_codec
+      video_sampling
+      width
+      x
+      y
+      zoom
+  ].map(&:to_sym)
+
+  def self.extract_config_params(options)
+      options.select{|k,v| URL_KEYS.include?(k)}
+  end
+
+  def self.extract_transformation_params(options)
+    options.select{|k,v| TRANSFORMATION_PARAMS.include?(k)}
+  end
+
+  def self.chain_transformation(options, *transformation)
+    base_options = extract_config_params(options)
+    transformation = transformation.reject(&:nil?)
+    base_options[:transformation] = build_array(extract_transformation_params(options)).concat(transformation)
+    base_options
+  end
+
+
   # Warning: options are being destructively updated!
   def self.generate_transformation_string(options={}, allow_implicit_crop_mode = false)
     # allow_implicit_crop_mode was added to support height and width parameters without specifying a crop mode.
     # This only apply to this (cloudinary_gem) SDK
 
     if options.is_a?(Array)
-      return options.map{|base_transformation| generate_transformation_string(base_transformation.clone, allow_implicit_crop_mode)}.join("/")
+      return options.map{|base_transformation| generate_transformation_string(base_transformation.clone, allow_implicit_crop_mode)}.reject(&:blank?).join("/")
     end
 
     symbolize_keys!(options)
@@ -105,6 +193,7 @@ class Cloudinary::Utils
     overlay = process_layer(options.delete(:overlay))
     underlay = process_layer(options.delete(:underlay))
     ifValue = process_if(options.delete(:if))
+    custom_function = process_custom_function(options.delete(:custom_function))
 
     params = {
       :a   => normalize_expression(angle),
@@ -116,6 +205,7 @@ class Cloudinary::Utils
       :dpr => normalize_expression(dpr),
       :e   => normalize_expression(effect),
       :fl  => flags,
+      :fn  => custom_function,
       :h   => normalize_expression(height),
       :l  => overlay,
       :o => normalize_expression(options.delete(:opacity)),
@@ -230,9 +320,13 @@ class Cloudinary::Utils
        text_style    = nil
        components    = []
 
-       unless public_id.blank?
-         public_id = public_id.gsub("/", ":")
-         public_id = "#{public_id}.#{format}" unless format.nil?
+       if public_id.present?
+          if type == "fetch" && public_id.match(%r(^https?:/)i)
+            public_id = Base64.urlsafe_encode64(public_id)
+          else
+            public_id = public_id.gsub("/", ":")
+            public_id = "#{public_id}.#{format}" if format
+          end
        end
 
        if text.blank? && resource_type != "text"
@@ -348,9 +442,9 @@ class Cloudinary::Utils
   # Warning: options are being destructively updated!
   def self.unsigned_download_url(source, options = {})
 
+    patch_fetch_format(options)
     type = options.delete(:type)
 
-    options[:fetch_format] ||= options.delete(:format) if type.to_s == "fetch"
     transformation = self.generate_transformation_string(options)
 
     resource_type = options.delete(:resource_type)
@@ -410,6 +504,7 @@ class Cloudinary::Utils
 
     transformation = transformation.gsub(%r(([^:])//), '\1/')
     if sign_url && ( !auth_token || auth_token.empty?)
+      raise(CloudinaryException, "Must supply api_secret") if (secret.nil? || secret.empty?)
       to_sign = [transformation, sign_version && version, source_to_sign].reject(&:blank?).join("/")
       to_sign = fully_unescape(to_sign)
       signature = 's--' + Base64.urlsafe_encode64(Digest::SHA1.digest(to_sign + secret))[0,8] + '--'
@@ -968,4 +1063,26 @@ class Cloudinary::Utils
   end
   private_class_method :process_video_params
 
+  def self.process_custom_function(param)
+    return param unless param.is_a? Hash
+
+    function_type = param[:function_type]
+    source = param[:source]
+
+    source = Base64.urlsafe_encode64(source) if function_type == "remote"
+    "#{function_type}:#{source}"
+  end
+
+  #
+  # Handle the format parameter for fetch urls
+  # @private
+  # @param options url and transformation options. This argument may be changed by the function!
+  #
+  def self.patch_fetch_format(options={})
+    if options[:type] === :fetch
+      format_arg = options.delete(:format)
+      options[:fetch_format] ||= format_arg
+    end
+  end
+
 end

data/lib/cloudinary/version.rb

@@ -1,4 +1,4 @@
 # Copyright Cloudinary
 module Cloudinary
-  VERSION = "1.9.1"
+  VERSION = "1.10.0"
 end

data/spec/access_control_spec.rb

@@ -9,6 +9,9 @@ def days(n)
 end
 
 describe "Access Control" do
+  before :each do
+    Cloudinary.reset_config
+  end
   let (:acl) {{
       :access_type => 'anonymous',
       :start => '2019-02-22 16:20:57 +0200',

data/spec/api_spec.rb

@@ -202,9 +202,9 @@ describe Cloudinary::Api do
 
   describe 'transformations' do
     it "should allow listing transformations" do
-      transformation = @api.transformations(max_results: 500)["transformations"].find { |transformation| transformation["name"] == TEST_TRANSFOMATION }
-      expect(transformation).not_to be_blank
-      expect(transformation["used"]).to eq(true)
+      transformations = @api.transformations()["transformations"]
+      expect(transformations[0]).not_to be_empty
+      expect(transformations[0]["used"]).to eq(true)
     end
 
     it "should allow getting transformation metadata" do
@@ -269,7 +269,7 @@ describe Cloudinary::Api do
         expect(RestClient::Request).to receive(:execute).with(deep_hash_value( [:payload, :named ]=> true))
         @api.transformations :named => true
       end
-      
+
     end
     it "should allow deleting implicit transformation" do
       @api.transformation(TEST_TRANSFOMATION)
@@ -467,12 +467,12 @@ describe Cloudinary::Api do
 
       expect(result["published"]).to be_an_instance_of(Array)
       expect(result["published"].length).to eq(1)
-
+      
       resource = result["published"][0]
-
+      
       expect(resource["public_id"]).to eq(publicId)
       expect(resource["type"]).to eq('upload')
-
+      
       bytes = resource["bytes"]
     end
     it "should publish resources by prefix and overwrite" do
@@ -480,13 +480,13 @@ describe Cloudinary::Api do
 
       expect(result["published"]).to be_an_instance_of(Array)
       expect(result["published"].length).to eq(1)
-
+      
       resource = result["published"][0]
-
+      
       expect(resource["public_id"]).to eq(publicId)
       expect(resource["bytes"]).not_to eq(bytes)
       expect(resource["type"]).to eq('upload')
-
+      
       bytes = resource["bytes"]
     end
     it "should publish resources by tag and overwrite" do
@@ -494,16 +494,22 @@ describe Cloudinary::Api do
 
       expect(result["published"]).to be_an_instance_of(Array)
       expect(result["published"].length).to eq(1)
-
+      
       resource = result["published"][0]
-
+      
       expect(resource["public_id"]).to eq(publicId)
       expect(resource["bytes"]).not_to eq(bytes)
       expect(resource["type"]).to eq('upload')
-
+      
       bytes = resource["bytes"]
     end
   end
+  describe "json breakpoints" do
+    it "should retrieve breakpoints as json array" do
+      bp = Cloudinary::Api.get_breakpoints(test_id_1, srcset: {min_width:10, max_width:2000, bytes_step: 10, max_images: 20})
+      expect(bp).to be_truthy
+    end
+  end
 end
 
 describe Cloudinary::Api::Response do

data/spec/auth_token_spec.rb

@@ -3,25 +3,23 @@ require 'spec_helper'
 require 'cloudinary'
 
 describe 'auth_token' do
-  before :all do
-    @url_backup = ENV["CLOUDINARY_URL"]
-  end
-  before do
-    Cloudinary.config_from_url "cloudinary://a:b@test123"
+
+  before :each do
+    Cloudinary.reset_config
+    Cloudinary.config_from_url 'cloudinary://a:b@test123'
     Cloudinary.config.auth_token = { :key => KEY, :duration => 300, :start_time => 11111111 }
   end
-  after do
-    ENV["CLOUDINARY_URL"] = @url_backup
-    Cloudinary::config_from_url @url_backup
-  end
   it "should generate with start and duration" do
     token = Cloudinary::Utils.generate_auth_token :start_time => 1111111111, :acl => "/image/*", :duration => 300
     expect(token).to eq '__cld_token__=st=1111111111~exp=1111111411~acl=%2fimage%2f*~hmac=1751370bcc6cfe9e03f30dd1a9722ba0f2cdca283fa3e6df3342a00a7528cc51'
   end
 
   describe "authenticated url" do
-    before do
+    before :each do
+      Cloudinary.class_variable_set :@@config, nil
+      Cloudinary.config_from_url 'cloudinary://a:b@test123'
       Cloudinary.config :private_cdn => true
+      Cloudinary.config.auth_token = { :key => KEY, :duration => 300, :start_time => 11111111 }
 
     end
     it "should add token if authToken is globally set and signed = true" do

data/spec/cache_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+require 'cloudinary'
+require 'cloudinary/cache'
+require 'rspec'
+require 'active_support/cache'
+
+describe 'Responsive cache' do
+
+  before :all do
+    Cloudinary.reset_config
+    unless defined? Rails and defined? Rails.cache
+      module Rails
+        class << self
+          attr_accessor :cache
+        end
+        Rails.cache = ActiveSupport::Cache::FileStore.new("#{Dir.getwd}/../tmp/cache")
+      end
+    end
+
+    Cloudinary::config.use_cache = true
+    Cloudinary::Cache.storage= Rails.cache
+    @i=0
+  end
+
+  after :all do
+    # Rails.cache.clear
+  end
+
+  def get_cache
+    Rails.cache.fetch CACHE_KEY do
+      @i = @i + 1
+    end
+  end
+  it 'should cache breakpoints' do
+    j = get_cache
+    j = get_cache
+
+    expect(j).to eql(1)
+    expect(@i).to eql(1)
+  end
+
+  it 'should cache upload results' do
+    result = Cloudinary::Uploader.upload(
+      TEST_IMG,
+      :tags => [TEST_TAG, TIMESTAMP_TAG],
+      responsive_breakpoints: [
+        {
+          create_derived: false,
+          transformation: {
+            angle: 90
+          },
+          format: 'gif'
+        },
+        {
+          create_derived: false,
+          transformation: {angle: 45, crop: 'scale'},
+          format: 'png'
+        },
+        {
+          create_derived: false,
+        }
+      ]
+    )
+    expect(result["responsive_breakpoints"]).to_not be_nil
+    expect(result["responsive_breakpoints"].length).to_not eql(0)
+    result["responsive_breakpoints"].each do |bp|
+      bp = Cloudinary::Cache.get(
+        result["public_id"],
+        {
+          type: bp["type"],
+          resource_type: bp["resource_type"],
+          raw_transformation: bp["transformation"]})
+      expect(bp).to_not be_nil
+    end
+  end
+  describe Cloudinary::Uploader do
+    let (:options) { {
+      :tags => [TEST_TAG, TIMESTAMP_TAG],
+        :use_cache => true,
+      :responsive_breakpoints => [
+        {
+          :create_derived => false,
+          :transformation => {
+            :angle => 90
+          },
+          :format => 'gif'
+        },
+        {
+          :create_derived => false,
+          :transformation => ResponsiveTest::TRANSFORMATION,
+          :format => ResponsiveTest::FORMAT
+        },
+        {
+          :create_derived => false
+        }
+      ]
+    }}
+    before :all do
+    end
+
+    it "Should save responsive breakpoints to cache after upload" do
+      result = Cloudinary::Uploader.upload( TEST_IMG, options)
+      cache_value = Cloudinary::Cache.get(result["public_id"], transformation: ResponsiveTest::TRANSFORMATION, format: ResponsiveTest::FORMAT)
+
+      expect(cache_value).to eql(ResponsiveTest::IMAGE_BP_VALUES)
+    end
+  end
+
+end