cloudinary 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 36330c17f742e019c7770d39fe11a5e394d69acc
-  data.tar.gz: 511246947d366e91a8d34095f256437bde533f9e
+  metadata.gz: 154b7abbf7ae3c462f1277f49dfed3cfdd4ef60c
+  data.tar.gz: 56a961c58cc636da0830ba4e1db3f486fe1dffd4
 SHA512:
-  metadata.gz: 4fcbb47f1760342d5e1b36e0438a605524eb20b9f0fac98521846f71102447ce6dda1ebb3f435e43d6227320bb48a65c85f5ae44da20b0c4fcb1539f7d78232a
-  data.tar.gz: 190f0970236cb76615d6537276fdd3633297e4c749815a6c54ae985188bee5e493d778a55c60798ac3ebaf9cb14930eb2b3589f45914c69cc489d378d5b19970
+  metadata.gz: 7fc132e944b87f3bd829f3e45a16609c7e4743a8fa331fad6d62a490a6f1625c533ea26b9eb50d1da71123abc5948166d5b606694b4765562877d255f54f93e9
+  data.tar.gz: 5a1ca4908473ea368ed4a2c1753852879fc75bf3dba22819f44637728de83c6a69f0a48482b5729e46d9f582a3c70748deeaad5dc683a8a2fa831ec784c3b302

data/CHANGELOG.md

@@ -1,4 +1,43 @@
 
+1.7.0 / 2017-04-09
+==================
+
+New functionality and features
+------------------------------
+
+  * Added resource publishing API
+    * `Api.publish_by_prefix`
+    * `Api.publish_by_tag`
+    * `Api.publish_by_ids`
+  * Support remote URLs in `Uploader.upload_large` API
+  * Add missing parameters to generate-archive
+    * `skip_transformation_name`
+    * `allow_missing`
+  * Added context API methods
+    * `Api.add_context`
+    * `Api.remove_all_context`
+  * Added `Uploader.remove_all_tags` method
+  * Support URL SEO suffix for authenticated images
+  * Add support of "format" parameter to responsive-breakpoints hash
+  * Add notification_url to update API
+  
+
+Other Changes
+-------------
+
+  * Remove tag from test
+  * Change test criteria from changing versions to bytes
+  * Use `TRAVIS_JOB_ID` if available or random. Move auth test constants to spec_helper.
+  * Add test for deleting public IDs which contain commas
+  * Move expression and replacement to constants
+  * Don't normalize negative numbers
+  * Added generic aliasing to methods named with image
+  * Added Private annotation to certain utility methods
+  * Add `encode_context` method to `Utils`
+  * Escape = and | characters in context values + test
+  * Add more complex eager test cases
+  * Switch alias_method_chain to alias_method to support Rails version >5.1
+
 1.6.0 / 2017-03-08
 ==================
 

data/lib/cloudinary/api.rb

@@ -88,7 +88,7 @@ class Cloudinary::Api
     uri            = "resources/#{resource_type}/#{type}/#{public_id}"
     update_options = {
       :tags               => options[:tags] && Cloudinary::Utils.build_array(options[:tags]).join(","),
-      :context            => Cloudinary::Utils.encode_hash(options[:context]),
+      :context            => Cloudinary::Utils.encode_context(options[:context]),
       :face_coordinates   => Cloudinary::Utils.encode_double_array(options[:face_coordinates]),
       :custom_coordinates => Cloudinary::Utils.encode_double_array(options[:custom_coordinates]),
       :moderation_status  => options[:moderation_status],
@@ -98,7 +98,8 @@ class Cloudinary::Api
       :detection          => options[:detection],
       :similarity_search  => options[:similarity_search],
       :background_removal => options[:background_removal],
-      :auto_tagging       => options[:auto_tagging] && options[:auto_tagging].to_f
+      :auto_tagging       => options[:auto_tagging] && options[:auto_tagging].to_f,
+      :notification_url   => options[:notification_url]
     }
     call_api(:post, uri, update_options, options)
   end
@@ -357,6 +358,24 @@ class Cloudinary::Api
     transformation.is_a?(String) ? transformation : Cloudinary::Utils.generate_transformation_string(transformation.clone)
   end
 
+  def self.publish_resources(options = {})
+    resource_type = options[:resource_type] || "image"
+    params = only(options, :public_ids, :prefix, :tag, :type, :overwrite, :invalidate)
+    call_api("post", "resources/#{resource_type}/publish_resources", params, options)
+  end
+
+  def self.publish_by_prefix(prefix, options = {})
+    return self.publish_resources(options.merge(:prefix => prefix))
+  end
+
+  def self.publish_by_tag(tag, options = {})
+    return self.publish_resources(options.merge(:tag => tag))
+  end
+
+  def self.publish_by_ids(publicIds, options = {})
+    return self.publish_resources(options.merge(:public_ids => publicIds))
+  end
+
   def self.update_resources_access_mode(access_mode, by_key, value, options = {})
     resource_type = options[:resource_type] || "image"
     type = options[:type] || "upload"

data/lib/cloudinary/helper.rb

@@ -75,6 +75,7 @@ module CloudinaryHelper
     url = cloudinary_url_internal(source, options)
     image_path_without_cloudinary(url)
   end
+  alias_method :cl_path, :cl_image_path
 
   def image_tag_with_cloudinary(*args)
     source, options = args
@@ -200,6 +201,7 @@ module CloudinaryHelper
   def cl_unsigned_image_upload(object_name, method, upload_preset, options={})
     cl_unsigned_image_upload_tag("#{object_name}[#{method}]", upload_preset, options)
   end
+  alias_method :cl_unsigned_upload, :cl_unsigned_image_upload
 
   def cl_upload_url(options={})
     Cloudinary::Utils.cloudinary_api_url("upload", {:resource_type=>:auto}.merge(options))
@@ -236,6 +238,7 @@ module CloudinaryHelper
   def cl_unsigned_image_upload_tag(field, upload_preset, options={})
     cl_image_upload_tag(field, options.merge(:unsigned => true, :upload_preset => upload_preset))
   end
+  alias_method :cl_unsigned_upload_tag, :cl_unsigned_image_upload_tag
 
   def cl_private_download_url(public_id, format, options = {})
     Cloudinary::Utils.private_download_url(public_id, format, options)
@@ -268,13 +271,12 @@ module CloudinaryHelper
       if !method_defined?(:image_tag)
         include ActionView::Helpers::AssetTagHelper
       end
-      if defined?(::Rails::VERSION::MAJOR) && ::Rails::VERSION::MAJOR > 2 && Cloudinary.config.enhance_image_tag
-        alias_method_chain :image_tag, :cloudinary unless public_method_defined? :image_tag_without_cloudinary
-        alias_method_chain :image_path, :cloudinary unless public_method_defined? :image_path_without_cloudinary
-      else
-        alias_method :image_tag_without_cloudinary, :image_tag unless public_method_defined? :image_tag_without_cloudinary
-        alias_method :image_path_without_cloudinary, :image_path unless public_method_defined? :image_path_without_cloudinary
-      end
+      alias_method :image_tag_without_cloudinary, :image_tag unless public_method_defined? :image_tag_without_cloudinary
+      alias_method :image_path_without_cloudinary, :image_path unless public_method_defined? :image_path_without_cloudinary
+      if Cloudinary.config.enhance_image_tag
+        alias_method :image_tag, :image_tag_with_cloudinary
+        alias_method :image_path, :image_path_with_cloudinary
+      end    
     end
   end
 
@@ -318,6 +320,7 @@ module Cloudinary::FormBuilder
   def cl_unsigned_image_upload(method, upload_preset, options={})
     @template.cl_unsigned_image_upload(@object_name, method, upload_preset, objectify_options(options))
   end
+  alias_method :cl_unsigned_upload, :cl_unsigned_image_upload
 end
 
 if defined? ActionView::Helpers::AssetUrlHelper

data/lib/cloudinary/uploader.rb

@@ -4,6 +4,8 @@ require 'json'
 
 class Cloudinary::Uploader
 
+  REMOTE_URL_REGEX = %r(^ftp:|^https?:|^s3:|^data:[^;]*;base64,([a-zA-Z0-9\/+\n=]+)$)
+
   # @deprecated use {Cloudinary::Utils.build_eager} instead
   def self.build_eager(eager)
     Cloudinary::Utils.build_eager(eager)
@@ -25,7 +27,7 @@ class Cloudinary::Uploader
       :callback                  => options[:callback],
       :categorization            => options[:categorization],
       :colors                    => Cloudinary::Utils.as_safe_bool(options[:colors]),
-      :context                   => Cloudinary::Utils.encode_hash(options[:context]),
+      :context                   => Cloudinary::Utils.encode_context(options[:context]),
       :custom_coordinates        => Cloudinary::Utils.encode_double_array(options[:custom_coordinates]),
       :detection                 => options[:detection],
       :discard_original_filename => Cloudinary::Utils.as_safe_bool(options[:discard_original_filename]),
@@ -71,7 +73,7 @@ class Cloudinary::Uploader
       params = build_upload_params(options)
       if file.is_a?(Pathname)
         params[:file] = File.open(file, "rb")
-      elsif file.respond_to?(:read) || file =~ /^ftp:|^https?:|^s3:|^data:[^;]*;base64,([a-zA-Z0-9\/+\n=]+)$/
+      elsif file.respond_to?(:read) || file.match(REMOTE_URL_REGEX)
         params[:file] = file
       else
         params[:file] = File.open(file, "rb")
@@ -89,7 +91,9 @@ class Cloudinary::Uploader
       public_id = public_id_or_options
       options   = old_options
     end
-    if file.is_a?(Pathname) || !file.respond_to?(:read)
+    if file.match(REMOTE_URL_REGEX)
+      return upload(file, options.merge(:public_id => public_id))
+    elsif file.is_a?(Pathname) || !file.respond_to?(:read)
       filename = file
       file     = File.open(file, "rb")
     else
@@ -255,6 +259,10 @@ class Cloudinary::Uploader
     return self.call_tags_api(tag, "replace", public_ids, options)
   end
 
+  def self.remove_all_tags(public_ids = [], options = {})
+    return self.call_tags_api(nil, "remove_all", public_ids, options)
+  end
+
   private
 
   def self.call_tags_api(tag, command, public_ids = [], options = {})
@@ -269,6 +277,28 @@ class Cloudinary::Uploader
     end
   end
 
+  def self.add_context(context, public_ids = [], options = {})
+    return self.call_context_api(context, "add", public_ids, options)
+  end
+
+  def self.remove_all_context(public_ids = [], options = {})
+    return self.call_context_api(nil, "remove_all", public_ids, options)
+  end
+
+  private
+
+  def self.call_context_api(context, command, public_ids = [], options = {})
+    return call_api("context", options) do
+      {
+        :timestamp  => (options[:timestamp] || Time.now.to_i),
+        :context    => Cloudinary::Utils.encode_hash(context),
+        :public_ids => Cloudinary::Utils.build_array(public_ids),
+        :command    => command,
+        :type       => options[:type]
+      }
+    end
+  end
+
   def self.call_api(action, options)
     options      = options.clone
     return_error = options.delete(:return_error)

data/lib/cloudinary/utils.rb

@@ -205,14 +205,14 @@ class Cloudinary::Utils
     end
   end
 
+  EXP_REGEXP = Regexp.new(PREDEFINED_VARS.keys.join("|")+'|('+CONDITIONAL_OPERATORS.keys.reverse.map { |k| Regexp.escape(k) }.join('|')+')(?=[ _])')
+  EXP_REPLACEMENT = PREDEFINED_VARS.merge(CONDITIONAL_OPERATORS)
+
   def self.normalize_expression(expression)
     if expression =~ /^!.+!$/ # quoted string
       expression
     else
-      expression.to_s.gsub(
-        Regexp.union(*PREDEFINED_VARS.keys, *CONDITIONAL_OPERATORS.keys.reverse),
-        PREDEFINED_VARS.merge(CONDITIONAL_OPERATORS)
-      ).gsub(/[ _]+/, "_")
+      expression.to_s.gsub(EXP_REGEXP,EXP_REPLACEMENT).gsub(/[ _]+/, "_")
     end
   end
 
@@ -321,12 +321,13 @@ class Cloudinary::Utils
       unless breakpoint_settings.nil?
         breakpoint_settings = breakpoint_settings.clone
         transformation =  breakpoint_settings.delete(:transformation) || breakpoint_settings.delete("transformation")
+        format =  breakpoint_settings.delete(:format) || breakpoint_settings.delete("format")
         if transformation
-          breakpoint_settings[:transformation] = Cloudinary::Utils.generate_transformation_string(transformation.clone, true)
+          transformation = Cloudinary::Utils.generate_transformation_string(transformation.clone, true)
         end
+        breakpoint_settings[:transformation] = [transformation, format].compact.join("/")
       end
       breakpoint_settings
-
     end.to_json
   end
 
@@ -450,6 +451,9 @@ class Cloudinary::Utils
       when resource_type.to_s == "image" && type.to_s == "private"
         resource_type = "private_images"
         type = nil
+      when resource_type.to_s == "image" && type.to_s == "authenticated"
+        resource_type = "authenticated_images"
+        type = nil
       when resource_type.to_s == "raw" && type.to_s == "upload"
         resource_type = "files"
         type = nil
@@ -457,7 +461,7 @@ class Cloudinary::Utils
         resource_type = "videos"
         type = nil
       else
-        raise(CloudinaryException, "URL Suffix only supported for image/upload, image/private and raw/upload")
+        raise(CloudinaryException, "URL Suffix only supported for image/upload, image/private, image/authenticated, video/upload and raw/upload")
       end
     end
     if use_root_path
@@ -668,6 +672,10 @@ class Cloudinary::Utils
     end
   end
 
+  # encodes a hash into pipe-delimited key-value pairs string
+  # @hash [Hash] key-value hash to be encoded
+  # @return [String] a joined string of all keys and values separated by a pipe character
+  # @private
   def self.encode_hash(hash)
     case hash
       when Hash then hash.map{|k,v| "#{k}=#{v}"}.join("|")
@@ -676,6 +684,18 @@ class Cloudinary::Utils
     end
   end
 
+  # Same like encode_hash, with additional escaping of | and = characters
+  # @hash [Hash] key-value hash to be encoded
+  # @return [String] a joined string of all keys and values properly escaped and separated by a pipe character
+  # @private
+  def self.encode_context(hash)
+    case hash
+      when Hash then hash.map{|k,v| "#{k}=#{v.gsub(/([=|])/, '\\\\\1')}"}.join("|")
+      when nil then ""
+      else hash
+    end
+  end
+
   def self.encode_double_array(array)
     array = build_array(array)
     if array.length > 0 && array[0].is_a?(Array)
@@ -804,7 +824,9 @@ class Cloudinary::Utils
       :public_ids=>options[:public_ids] && Cloudinary::Utils.build_array(options[:public_ids]),
       :prefixes=>options[:prefixes] && Cloudinary::Utils.build_array(options[:prefixes]),
       :expires_at=>options[:expires_at],
-      :transformations => build_eager(options[:transformations])
+      :transformations => build_eager(options[:transformations]),
+      :skip_transformation_name=>Cloudinary::Utils.as_safe_bool(options[:skip_transformation_name]),
+      :allow_missing=>Cloudinary::Utils.as_safe_bool(options[:allow_missing])
     }
   end
 

data/lib/cloudinary/version.rb

@@ -1,4 +1,4 @@
 # Copyright Cloudinary
 module Cloudinary
-  VERSION = "1.6.0"
+  VERSION = "1.7.0"
 end

data/spec/api_spec.rb

@@ -6,7 +6,7 @@ describe Cloudinary::Api do
   include_context "cleanup", TIMESTAMP_TAG
   TEST_WIDTH = rand(1000)
   TEST_TRANSFOMATION = "c_scale,w_#{TEST_WIDTH}"
-  prefix = "api_test_#{Time.now.to_i}"
+  prefix = "api_test_#{SUFFIX}"
   test_id_1 = "#{prefix}_1"
   test_id_2   = "#{prefix}_2"
   test_id_3   = "#{prefix}_3"
@@ -157,9 +157,11 @@ describe Cloudinary::Api do
 
   end
 
-  it "should allow deleting resources" do
+  it "should allow deleting multiple resources and comma inclusive public IDs", :focus => true do
     expect(RestClient::Request).to receive(:execute).with(deep_hash_value( {[:payload, :public_ids] => ["apit_test", "test_id_2", "api_test3"]}))
     @api.delete_resources(["apit_test", "test_id_2", "api_test3"])
+    expect(RestClient::Request).to receive(:execute).with(deep_hash_value( {[:payload, :public_ids] => "apit_test,test_id_2,api_test3"}))
+    @api.delete_resources("apit_test,test_id_2,api_test3")
   end
 
   it "should allow deleting resource transformations" do
@@ -352,9 +354,13 @@ describe Cloudinary::Api do
     expect{Cloudinary::Api.update(result["public_id"], {:categorization => :illegal})}.to raise_error(Cloudinary::Api::BadRequest, /^Illegal value/)
   end
   
-  it "should support requesting detection" do
-    expect(RestClient::Request).to receive(:execute).with(deep_hash_value( [:payload, :detection] => "adv_face"))
-    Cloudinary::Api.update("public_id", {:detection => "adv_face"})
+  it "should support requesting detection with server notification", :focus => true do
+    expected = {
+      [:payload, :detection] => "adv_face",
+      [:payload, :notification_url] => "http://example.com"
+    }
+    expect(RestClient::Request).to receive(:execute).with(deep_hash_value(expected))
+    Cloudinary::Api.update("public_id", {:detection => "adv_face", :notification_url => "http://example.com"})
   end
   
   it "should support requesting auto_tagging" do
@@ -437,4 +443,60 @@ describe Cloudinary::Api do
       expect(resource["access_mode"]).to eq('public')
     end
   end
+
+  context "resource of type authenticated" do
+    i = 0
+    bytes = nil
+    publicId = ""
+    publish_resource_tag = "publish_resource_tag"
+    before(:each) do
+      i += 1
+      result = Cloudinary::Uploader.upload TEST_IMG, type: "authenticated", tags: [TEST_TAG, TIMESTAMP_TAG, publish_resource_tag], transformation: {width: 100*i, crop: "scale"}
+      publicId = result["public_id"]
+      expect(result["type"]).to eq("authenticated")
+    end
+
+    it "should publish resources by ids" do
+      result = Cloudinary::Api.publish_by_ids( [publicId])
+
+      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
+      result = Cloudinary::Api.publish_by_prefix(publicId[0..-3], overwrite: true)
+
+      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
+      result = Cloudinary::Api.publish_by_tag(publish_resource_tag, overwrite: true)
+
+      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
 end

data/spec/archive_spec.rb

@@ -22,6 +22,12 @@ RSpec.shared_context 'archive' do
         :effect => :blackwhite
       }
     )
+    Cloudinary::Uploader.upload(
+      "http://res.cloudinary.com/demo/image/upload/sample.jpg",
+      :public_id      => 'tag_sample_raw.jpg',
+      :resource_type  => 'raw',
+      :tags           => [TEST_TAG, TIMESTAMP_TAG],
+    )
   end
   include_context "cleanup", TIMESTAMP_TAG
 end
@@ -62,20 +68,8 @@ describe Cloudinary::Uploader do
 
   describe '.create_archive' do
     let!(:target_public_id) {
-      "gem_test#{ rand(1000000)}"
-    }
-    let!(:archive_result) {
-      Cloudinary::Uploader.create_archive(
-        {
-          :target_public_id => target_public_id,
-          :public_ids       => %w(tag_sample tag_samplebw),
-          :tags             => [TEST_TAG, TIMESTAMP_TAG]
-        }.merge(options))
+      "gem_test#{ SUFFIX}"
     }
-    let(:options) { { :mode => :create } }
-    it 'should return a Hash' do
-      expect(archive_result).to be_a(Hash)
-    end
     expected_keys = %w(
               resource_type
               type
@@ -91,10 +85,41 @@ describe Cloudinary::Uploader do
               resource_count
               file_count
             )
-    it "should include keys: #{expected_keys.join(', ')}" do
+    let!(:archive_result) {
+      Cloudinary::Uploader.create_archive(
+        {
+          :target_public_id => target_public_id,
+          :public_ids       => %w(tag_sample tag_samplebw),
+          :tags             => [TEST_TAG, TIMESTAMP_TAG],
+          :transformations   => [{width: 100, height: 100, crop: "fill"},{effect: "grayscale"}],
+          :skip_transformation_name => true
+        }.merge(options))
+    }
+    let(:options) { { :mode => :create } }
+    it 'should return a Hash with suitable set of keys' do
+      expect(archive_result).to be_a(Hash)
       expect(archive_result.keys).to include(*expected_keys)
     end
   end
+  describe 'create archive based on raw resources and missing public IDs' do
+    let!(:target_public_id) {
+      "gem_test#{ SUFFIX}"
+    }
+    let!(:archive_result) {
+      Cloudinary::Uploader.create_archive(
+        {
+          :target_public_id => target_public_id,
+          :public_ids       => %w(tag_sample_raw.jpg non-wxisting-resource),
+          :resource_type    => 'raw',
+          :allow_missing    => true
+        }.merge(options))
+    }
+    let(:options) { { :mode => :create } }
+    it 'should skip missing public IDs and successfully generate the archive containing raw resources' do
+      expect(archive_result).to be_a(Hash)
+      expect(archive_result["resource_count"]).to equal(1)
+    end
+  end
   describe '.create_zip' do
     it 'should call create_archive with "zip" format' do
       expect(Cloudinary::Uploader).to receive(:create_archive).with({ :tags => TEST_TAG }, "zip")