cloudinary 1.11.1 → 1.12.0

data/spec/spec_helper.rb

@@ -1,8 +1,11 @@
+SUFFIX = ENV['TRAVIS_JOB_ID'] || rand(999999999).to_s
+
 require 'rspec'
 require 'rexml/parsers/ultralightparser'
 require 'nokogiri'
 require 'rspec/version'
 require 'rest_client'
+require 'active_storage/test_helper' if RUBY_VERSION >= '2.2.2'
 require 'cloudinary'
 
 Cloudinary.config.enhance_image_tag = true
@@ -10,11 +13,15 @@ Cloudinary.config.enhance_image_tag = true
 DUMMY_CLOUD = "test123"
 TEST_IMAGE_URL = "http://cloudinary.com/images/old_logo.png"
 TEST_IMG = "spec/logo.png"
+TEST_VIDEO = "spec/movie.mp4"
+TEST_RAW = "spec/docx.docx"
 TEST_IMG_W = 241
 TEST_IMG_H = 51
-SUFFIX = ENV['TRAVIS_JOB_ID'] || rand(999999999).to_s
 TEST_TAG = 'cloudinary_gem_test'
 TIMESTAMP_TAG = "#{TEST_TAG}_#{SUFFIX}_#{RUBY_VERSION}_#{ defined? Rails::version ? Rails::version : 'no_rails'}"
+UNIQUE_TEST_FOLDER = "#{TEST_TAG}_#{SUFFIX}_folder"
+NEXT_CURSOR = "db27cfb02b3f69cb39049969c23ca430c6d33d5a3a7c3ad1d870c54e1a54ee0faa5acdd9f6d288666986001711759d10"
+GENERIC_FOLDER_NAME = "some_folder"
 
 # Auth token
 KEY     = "00112233FF99"
@@ -263,4 +270,4 @@ module Cloudinary
   end
 
   private_class_method :arrays_match?, :hashes_match?
-end
+end

data/spec/uploader_spec.rb

@@ -49,6 +49,24 @@ describe Cloudinary::Uploader do
     end
   end
 
+  it "should support the cinemagraph_analysis parameter for upload" do
+    expected = {
+        [:payload, :cinemagraph_analysis] => 1,
+        [:method] => :post
+    }
+    expect(RestClient::Request).to receive(:execute).with(deep_hash_value(expected))
+    Cloudinary::Uploader.upload(Pathname.new(TEST_IMG), :cinemagraph_analysis => true, :tags => [TEST_TAG, TIMESTAMP_TAG])
+  end
+
+  it "should support the cinemagraph_analysis parameter for explicit" do
+    expected = {
+        [:payload, :cinemagraph_analysis] => 1,
+        [:method] => :post
+    }
+    expect(RestClient::Request).to receive(:execute).with(deep_hash_value(expected))
+    Cloudinary::Uploader.explicit('sample', :type => "upload", :cinemagraph_analysis => true, :tags => [TEST_TAG, TIMESTAMP_TAG])
+  end
+
   describe '.rename' do
     before(:all) do
       @result        = Cloudinary::Uploader.upload(TEST_IMG, :tags => [TEST_TAG, TIMESTAMP_TAG])
@@ -105,7 +123,7 @@ describe Cloudinary::Uploader do
     expect(RestClient::Request).to receive(:execute).with(deep_hash_value( [:payload, :public_id] => "sample", [:payload, :eager] => "c_scale,w_2.0"))
     result = Cloudinary::Uploader.explicit("sample", :type=>"upload", :eager=>[{:crop=>"scale", :width=>"2.0"}])
   end
-  
+
   it "should support eager" do
     result = Cloudinary::Uploader.upload(TEST_IMG, :eager =>[{ :crop =>"scale", :width =>"2.0"}], :tags => [TEST_TAG, TIMESTAMP_TAG])
     expect(result["eager"].length).to be(1)
@@ -286,7 +304,7 @@ describe Cloudinary::Uploader do
   end
     
   it "should support requesting raw conversion" do
-    expect{Cloudinary::Uploader.upload("spec/docx.docx", {:resource_type => :raw, :raw_convert => :illegal, :tags => [TEST_TAG, TIMESTAMP_TAG]})}.to raise_error(CloudinaryException, /Illegal value|not a valid|is invalid/)
+    expect{Cloudinary::Uploader.upload(TEST_RAW, {:resource_type => :raw, :raw_convert => :illegal, :tags => [TEST_TAG, TIMESTAMP_TAG]})}.to raise_error(CloudinaryException, /Illegal value|not a valid|is invalid/)
   end
   
   it "should support requesting categorization" do
@@ -380,7 +398,6 @@ describe Cloudinary::Uploader do
 
 
   describe 'explicit' do
-
     context ":invalidate" do
       it 'should pass the invalidate value to the server' do
         expect(RestClient::Request).to receive(:execute).with(deep_hash_value( [:payload, :invalidate] => 1))

data/spec/utils_methods_spec.rb

@@ -1,7 +1,6 @@
 require 'rspec'
 require 'spec_helper'
 require 'cloudinary'
-
 include Cloudinary
 
 describe Utils do
@@ -51,4 +50,32 @@ describe Utils do
       expect(result).to include('foobar')
     end
   end
-end
+  describe 'is_remote_url' do
+    it 'should identify remote URLs correctly' do
+      [
+        "ftp://ftp.cloudinary.com/images/old_logo.png",
+        "http://cloudinary.com/images/old_logo.png",
+        "https://cloudinary.com/images/old_logo.png",
+        "s3://s3-us-west-2.amazonaws.com/cloudinary/images/old_logo.png",
+        "gs://cloudinary/images/old_logo.png",
+        "data:image/gif;charset=utf8;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7",
+        "data:image/gif;param1=value1;param2=value2;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7"
+      ].each do |url|
+        expect(Cloudinary::Utils.is_remote?(url)).to eq(true), url
+      end
+    end
+  end
+  describe "resource_type per format" do
+    it "should return the correct resource_type per format" do
+      format_to_resource_type = {
+        "jpg" => "image",
+        "mp4" => "video",
+        "txt" => "raw",
+        "mp3" => "video",
+      }
+      format_to_resource_type.each do |format, resource_type|
+        expect(Cloudinary::Utils.resource_type_for_format(format)).to eq(resource_type)
+      end
+    end
+  end
+end

data/spec/utils_spec.rb

@@ -319,40 +319,48 @@ describe Cloudinary::Utils do
   end
 
   describe ":transformation" do
-    it "should support named tranformation" do
+    it "should support named transformation" do
       expect(["test", { :transformation => "blip" }])
         .to produce_url("#{upload_path}/t_blip/test")
               .and empty_options
     end
 
-    it "should support array of named tranformations" do
+    it "should support array of named transformation" do
       expect(["test", { :transformation => ["blip", "blop"] }])
         .to produce_url("#{upload_path}/t_blip.blop/test")
               .and empty_options
     end
 
-    it "should support base tranformation" do
+    it "should support base transformation" do
       expect(["test", { :transformation => { :x => 100, :y => 100, :crop => :fill }, :crop => :crop, :width => 100 }])
         .to produce_url("#{upload_path}/c_fill,x_100,y_100/c_crop,w_100/test")
               .and mutate_options_to({ :width => 100 })
     end
 
-    it "should support array of base tranformations" do
+    it "should support array of base transformation" do
       expect(["test", { :transformation => [{ :x => 100, :y => 100, :width => 200, :crop => :fill }, { :radius => 10 }], :crop => :crop, :width => 100 }])
         .to produce_url("#{upload_path}/c_fill,w_200,x_100,y_100/r_10/c_crop,w_100/test")
               .and mutate_options_to({ :width => 100 })
     end
 
-    it "should support array of tranformations" do
+    it "should support array of transformation" do
       result = Cloudinary::Utils.generate_transformation_string([{ :x => 100, :y => 100, :width => 200, :crop => :fill }, { :radius => 10 }])
       expect(result).to eq("c_fill,w_200,x_100,y_100/r_10")
     end
 
-    it "should not include empty tranformations" do
+    it "should not include empty transformation" do
       expect(["test", { :transformation => [{}, { :x => 100, :y => 100, :crop => :fill }, {}] }])
         .to produce_url("#{upload_path}/c_fill,x_100,y_100/test")
               .and empty_options
     end
+
+    describe "should support and translate arithmetic operators" do
+      it "should support * / + - ^" do
+        t = [{:width => 'initial_width * 2 / 3 ^ 2', :height => 'initial_height + 2 - 3', :crop => 'scale'}]
+        expected_trans = "c_scale,h_ih_add_2_sub_3,w_iw_mul_2_div_3_pow_2"
+        expect(Cloudinary::Utils.cloudinary_url('sample', :transformation => t)).to eq("#{upload_path}/#{expected_trans}/sample")
+      end
+    end
   end
 
 
@@ -428,6 +436,34 @@ describe Cloudinary::Utils do
             .and empty_options
   end
 
+  it "should process the radius correctly when given valid values" do
+    valid_radius_test_values = [
+      [10, 'r_10'],
+      ['10', 'r_10'],
+      ['$v', 'r_$v'],
+      [[10, 20, 30], 'r_10:20:30'],
+      [[10, 20, '$v'], 'r_10:20:$v'],
+      [[10, 20, '$v', 40], 'r_10:20:$v:40'],
+      [['10:20'], 'r_10:20'],
+      [['10:20:$v:40'], 'r_10:20:$v:40']
+    ]
+    valid_radius_test_values.each do |options, expected|
+      expect(["test", { :transformation => { :radius => options } }])
+        .to produce_url("#{root_path}/image/upload/#{expected}/test") .and empty_options
+    end
+  end
+
+  it "should throw an error when the radius is given invalid values" do
+    invalid_radius_test_values = [
+      [],
+      [10,20,30,40,50]
+    ]
+    invalid_radius_test_values.each do |options|
+      expect{Cloudinary::Utils.cloudinary_url("test", {:transformation => {:radius => options}})}
+        .to raise_error(CloudinaryException)
+    end
+  end
+
   it "should support format for fetch urls" do
     expect(["http://cloudinary.com/images/logo.png", { :format => "jpg", :type => :fetch }])
       .to produce_url("#{root_path}/image/fetch/f_jpg/http://cloudinary.com/images/logo.png")
@@ -578,6 +614,8 @@ describe Cloudinary::Utils do
           ["text parameter", { :public_id => "test_text", :text => text_layer }, "text:test_text:#{text_encoded}"],
           ["text with font family and size parameters", { :text => text_layer, :font_family => "Arial", :font_size => "18" }, "text:Arial_18:#{text_encoded}"],
           ["text with text style parameter", { :text => text_layer, :font_family => "Arial", :font_size => "18", :font_weight => "bold", :font_style => "italic", :letter_spacing => 4, :line_spacing => 2 }, "text:Arial_18_bold_italic_letter_spacing_4_line_spacing_2:#{text_encoded}"],
+          ["text with antialiasing and font hinting", { :text => "Hello World, Nice to meet you?", :font_family => "Arial", :font_size => "18", :font_antialiasing => "best", :font_hinting => "medium"}, "text:Arial_18_antialias_best_hinting_medium:Hello%20World%252C%20Nice%20to%20meet%20you%3F"],
+          ["text with text style parameter (explicit)", "text:Arial_18_antialias_best_hinting_medium:Hello%20World%252C%20Nice%20to%20meet%20you%3F", "text:Arial_18_antialias_best_hinting_medium:Hello%20World%252C%20Nice%20to%20meet%20you%3F"],
           ["subtitles", { :resource_type => "subtitles", :public_id => "subtitles.srt" }, "subtitles:subtitles.srt"],
           ["subtitles with font family and size", { :resource_type => "subtitles", :public_id => "subtitles.srt", :font_family => "Arial", :font_size => "40" }, "subtitles:Arial_40:subtitles.srt"],
           ["image of type fetch", { :public_id => "http://res.cloudinary.com/demo/image/upload/ci", :type => "fetch" }, "fetch:aHR0cDovL3Jlcy5jbG91ZGluYXJ5LmNvbS9kZW1vL2ltYWdlL3VwbG9hZC9jaQ=="]
@@ -732,6 +770,51 @@ describe Cloudinary::Utils do
             .and empty_options
   end
 
+  it "should default force_version to True if no value is given" do
+    expect(["folder/test", {}])
+      .to produce_url("#{upload_path}/v1/folder/test")
+        .and empty_options
+  end
+
+  it "should exclude the version if resource is stored in a folder and force_version is False" do
+    expect(["folder/test", {:force_version => false}])
+      .to produce_url("#{upload_path}/folder/test")
+        .and empty_options
+  end
+
+  it "should include the version if given explicitly regardless of force_verison (without folder)" do
+    expect(["test", {:force_version => false, :version => 12345}])
+      .to produce_url("#{upload_path}/v12345/test")
+        .and empty_options
+  end
+
+  it "should include the version if given explicitly regardless of force_verison (with folder)" do
+    expect(["folder/test", {:force_version => false, :version => 12345}])
+      .to produce_url("#{upload_path}/v12345/folder/test")
+        .and empty_options
+  end
+
+  it "should use the force_version option if set in the global config" do
+    Cloudinary.config(:force_version => false)
+    expect(["folder/test", {}])
+      .to produce_url("#{upload_path}/folder/test")
+        .and empty_options
+  end
+
+  it "should ignore the global force_version config if version is set explicitly in the options" do
+    Cloudinary.config(:force_version => false)
+    expect(["folder/test", {:version => 12345}])
+      .to produce_url("#{upload_path}/v12345/folder/test")
+        .and empty_options
+  end
+
+  it "should override global config option if force_version is given within options" do
+    Cloudinary.config(:force_version => false)
+    expect(["folder/test", {:force_version => true}])
+      .to produce_url("#{upload_path}/v1/folder/test")
+        .and empty_options
+  end
+
   it "should allow to shorted image/upload urls" do
     expect(["test", { :shorten => true }])
       .to produce_url("#{root_path}/iu/test")
@@ -875,11 +958,9 @@ describe Cloudinary::Utils do
                  :effect =>"grayscale"])
           .to produce_url("#{upload_path}/#{all_operators}/sample")
     end
-
     end
-  end
 
-  describe "variables" do
+    describe "variables" do
     it "array should define a set of variables" do
       options = {
           :if => "face_count > 2",
@@ -909,7 +990,7 @@ describe Cloudinary::Utils do
     end
   end
 
-  describe "context" do
+    describe "context" do
     it 'should escape pipe and backslash characters' do
       context = {"caption" => "different = caption", "alt2" => "alt|alternative"}
       result = Cloudinary::Utils.encode_context(context)
@@ -925,7 +1006,7 @@ describe Cloudinary::Utils do
     end
   end
 
-  describe "customFunction" do
+    describe "customFunction" do
     custom_function_wasm = {
       :function_type => 'wasm',
       :source => 'blur.wasm'
@@ -967,4 +1048,5 @@ describe Cloudinary::Utils do
     end
 
   end
+  end
 end

data/vendor/assets/javascripts/cloudinary/jquery.cloudinary.js

@@ -802,7 +802,7 @@ var slice = [].slice,
     function TextLayer(options) {
       var keys;
       TextLayer.__super__.constructor.call(this, options);
-      keys = ["resourceType", "resourceType", "fontFamily", "fontSize", "fontWeight", "fontStyle", "textDecoration", "textAlign", "stroke", "letterSpacing", "lineSpacing", "text"];
+      keys = ["resourceType", "resourceType", "fontFamily", "fontSize", "fontWeight", "fontStyle", "textDecoration", "textAlign", "stroke", "letterSpacing", "lineSpacing", "fontHinting", "fontAntialiasing", "text"];
       if (options != null) {
         keys.forEach((function(_this) {
           return function(key) {
@@ -871,6 +871,16 @@ var slice = [].slice,
       return this;
     };
 
+    TextLayer.prototype.fontAntialiasing = function(fontAntialiasing){
+      this.options.fontAntialiasing = fontAntialiasing;
+      return this;
+    };
+
+    TextLayer.prototype.fontHinting = function(fontHinting ){
+      this.options.fontHinting  = fontHinting ;
+      return this;
+    };
+
     TextLayer.prototype.text = function(text) {
       this.options.text = text;
       return this;
@@ -932,6 +942,12 @@ var slice = [].slice,
       if (!(Util.isEmpty(this.options.lineSpacing) && !Util.isNumberLike(this.options.lineSpacing))) {
         components.push("line_spacing_" + this.options.lineSpacing);
       }
+      if (this.options.fontAntialiasing !== "none") {
+        components.push("antialias_"+this.options.fontAntialiasing);
+      }
+      if (this.options.fontHinting !== "none") {
+        components.push("hinting_"+this.options.fontHinting);
+      }
       if (!Util.isEmpty(Util.compact(components))) {
         if (Util.isEmpty(this.options.fontFamily)) {
           throw "Must supply fontFamily. " + components;
@@ -2780,6 +2796,20 @@ var slice = [].slice,
       return this.param(value, "gravity", "g");
     };
 
+    Transformation.prototype.fps = function(value) {
+      return this.param(value, "fps", "fps", (function(_this) {
+        return function(fps) {
+          if (Util.isString(fps)) {
+            return fps;
+          } else if (Util.isArray(fps)) {
+            return fps.join("-");
+          } else {
+            return fps;
+          }
+        };
+      })(this));
+    };
+
     Transformation.prototype.height = function(value) {
       return this.param(value, "height", "h", (function(_this) {
         return function() {

data/vendor/assets/javascripts/cloudinary/jquery.fileupload.js

@@ -43,7 +43,7 @@
             '|(Kindle/(1\\.0|2\\.[05]|3\\.0))'
     ).test(window.navigator.userAgent) ||
         // Feature detection for all other devices:
-        $('<input type="file">').prop('disabled'));
+        $('<input type="file"/>').prop('disabled'));
 
     // The FileReader API is not actually used, but works as feature detection,
     // as some Safari versions (5?) support XHR file uploads via the FormData API,
@@ -261,6 +261,9 @@
             // Callback for dragover events of the dropZone(s):
             // dragover: function (e) {}, // .bind('fileuploaddragover', func);
 
+            // Callback before the start of each chunk upload request (before form data initialization):
+            // chunkbeforesend: function (e, data) {}, // .bind('fileuploadchunkbeforesend', func);
+
             // Callback for the start of each chunk upload request:
             // chunksend: function (e, data) {}, // .bind('fileuploadchunksend', func);
 
@@ -434,6 +437,13 @@
             }
         },
 
+        _deinitProgressListener: function (options) {
+            var xhr = options.xhr ? options.xhr() : $.ajaxSettings.xhr();
+            if (xhr.upload) {
+                $(xhr.upload).unbind('progress');
+            }
+        },
+
         _isInstanceOf: function (type, obj) {
             // Cross-frame instanceof check
             return Object.prototype.toString.call(obj) === '[object ' + type + ']';
@@ -453,7 +463,7 @@
             }
             if (!multipart || options.blob || !this._isInstanceOf('File', file)) {
                 options.headers['Content-Disposition'] = 'attachment; filename="' +
-                    encodeURI(file.name) + '"';
+                    encodeURI(file.uploadName || file.name) + '"';
             }
             if (!multipart) {
                 options.contentType = file.type || 'application/octet-stream';
@@ -489,7 +499,11 @@
                         });
                     }
                     if (options.blob) {
-                        formData.append(paramName, options.blob, file.name);
+                        formData.append(
+                            paramName,
+                            options.blob,
+                            file.uploadName || file.name
+                        );
                     } else {
                         $.each(options.files, function (index, file) {
                             // This check allows the tests to run with
@@ -762,6 +776,8 @@
                 // Expose the chunk bytes position range:
                 o.contentRange = 'bytes ' + ub + '-' +
                     (ub + o.chunkSize - 1) + '/' + fs;
+                // Trigger chunkbeforesend to allow form data to be updated for this chunk
+                that._trigger('chunkbeforesend', null, o);
                 // Process the upload data (the blob and potential form data):
                 that._initXHRData(o);
                 // Add progress listeners for this chunk upload:
@@ -808,6 +824,9 @@
                             o.context,
                             [jqXHR, textStatus, errorThrown]
                         );
+                    })
+                    .always(function () {
+                        that._deinitProgressListener(o);
                     });
             };
             this._enhancePromise(promise);
@@ -909,6 +928,7 @@
                     }).fail(function (jqXHR, textStatus, errorThrown) {
                         that._onFail(jqXHR, textStatus, errorThrown, options);
                     }).always(function (jqXHRorResult, textStatus, jqXHRorError) {
+                        that._deinitProgressListener(options);
                         that._onAlways(
                             jqXHRorResult,
                             textStatus,
@@ -1126,7 +1146,7 @@
                 dirReader = entry.createReader();
                 readEntries();
             } else {
-                // Return an empy list for file system items
+                // Return an empty list for file system items
                 // other than files or directories:
                 dfd.resolve([]);
             }