cloudinary 1.0.78 → 1.0.79

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
 SHA1: 
-  metadata.gz: 1b465c67371871382525ab5dd84b4ac295ca59f9
-  data.tar.gz: a46f2de133c16575112eaefb0c92955080f759a4
+  metadata.gz: b29c537f39a98d72f302907e0f50fbb8cafa1a10
+  data.tar.gz: b8a1adc7b8fe8f9bc154f909e44b4ef0a16387fc
 SHA512: 
-  metadata.gz: 21755db5865749be5a67c64ce750d8666618325d0f7d1b5713e0297aa02f30d40d20da5859896036aeb3f6f0312dd2c1b47b0b0cc5e539bd9333bf474653abbb
-  data.tar.gz: a2b04439ffaae15f62100723b97a4ac52e0c543e07f5e2af3f5e644ac1957c962b7cadf522d932641915c9f2c960db8e1119e0db401126860f63dd8596c8ef2a
+  metadata.gz: 1fc90e873024c8b1f8f75abf0500684024b3fd5fee87086eecf078645466378bdc3a8fc7965f9c034b3567ff03d8a150f613692b1078110a4aa2721bde21dd79
+  data.tar.gz: 3edd3c23ec7e6053f03a0670e0910dbfddf9260e1ccfe411635c0749db175229eb6b4412b37e0d99591808be159686eea2b6068d407fbb0dccd3aac2a3d4c162

data/CHANGELOG

@@ -1,3 +1,13 @@
+= Version 1.0.79 - 2014-12-11
+  * Support folder listing API.
+  * Add support for conditional processing in CarrierWave plugin.
+  * Support tags in upload_large.
+  * Support url_suffix and use_root_path for private_cdn URL building.
+  * Allow using sign_url with type authenticated.
+  * Don't sign version component by default.
+  * Support for new domain sharding syntax and secure domain sharding. Support for secure_cdn_subdomain flag.
+  * Update Cloudinary's jQuery plugin to v1.0.21.
+
 = Version 1.0.78 - 2014-11-04
   * Add app_root method that handled Rails.root, which is a String in old Rails versions.
   * Issue #127 - solve cyclical dependency in case cloudinary was included after Rails was initialized.

data/lib/cloudinary/api.rb

@@ -171,6 +171,14 @@ class Cloudinary::Api
     params = Cloudinary::Uploader.build_upload_params(options)
     call_api(:post, "upload_presets", params.merge(only(options, :name, :unsigned, :disallow_public_id)), options)
   end
+
+  def self.root_folders(options={})
+    call_api(:get, "folders", {}, options)
+  end
+
+  def self.subfolders(of_folder_path, options={})
+    call_api(:get, "folders/#{of_folder_path}", {}, options)
+  end
   
   protected
   

data/lib/cloudinary/carrier_wave/preloaded.rb

@@ -1,6 +1,6 @@
 # Copyright Cloudinary
 # Support for store in CarrierWave files that were preloaded to cloudinary (e.g., by javascript)
-# Field value must be in the format:  "image/upload/v<version>/#<public_id>.<format>#<signature>"
+# Field value must be in the format:  "image/upload/v<version>/<public_id>.<format>#<signature>"
 # Where signature is the cloduinary API signature on the public_id and version.
 module Cloudinary::CarrierWave
   PRELOADED_CLOUDINARY_PATH = Cloudinary::PreloadedFile::PRELOADED_CLOUDINARY_PATH
@@ -90,4 +90,4 @@ module Cloudinary::CarrierWave
     return PreloadedCloudinaryFile.new(file) if file.is_a?(String) && file.match(PRELOADED_CLOUDINARY_PATH)
     nil
   end
-end
+end

data/lib/cloudinary/carrier_wave/process.rb

@@ -3,48 +3,48 @@ module Cloudinary::CarrierWave
     def make_private
       self.storage_type = :private
     end
-    
+
     def process_all_versions(*args)
       @all_versions ||= Class.new(self)
       @all_versions.process *args
     end
-        
+
     def eager
       process :eager => true
     end
-    
+
     def convert(format)
       process :convert => format
     end
-  
+
     def resize_to_limit(width, height)
       process :resize_to_limit => [width, height]
     end
-  
+
     def resize_to_fit(width, height)
       process :resize_to_fit => [width, height]
     end
-  
+
     def resize_to_fill(width, height, gravity="Center")
       process :resize_to_fill => [width, height, gravity]
     end
-  
+
     def resize_and_pad(width, height, background=:transparent, gravity="Center")
       process :resize_and_pad => [width, height, background, gravity]
-    end    
-  
+    end
+
     def scale(width, height)
       process :scale => [width, height]
-    end    
-  
+    end
+
     def crop(width, height, gravity="Center")
       process :crop => [width, height, gravity]
     end
-  
+
     def cloudinary_transformation(options)
       process :cloudinary_transformation => options
     end
-    
+
     def tags(*tags)
       process :tags=>tags
     end
@@ -54,35 +54,43 @@ module Cloudinary::CarrierWave
     raise CloudinaryException, "conflicting transformation on #{attr} #{value}!=#{hash[attr]}" if hash[attr] && hash[attr] != value
     hash[attr] = value
   end
-  
+
   def transformation
     return @transformation if @transformation
     @transformation = {}
-    self.all_processors.each do
-      |name, args|
+    self.all_processors.each do |name, args, condition|
+
+      if(condition)
+        if condition.respond_to?(:call)
+          next unless condition.call(self, :args => args)
+        else
+          next unless self.send(condition)
+        end
+      end
+
       case name
       when :convert # Do nothing. This is handled by format
-      when :resize_to_limit 
-        set_or_yell(@transformation, :width, args[0])    
+      when :resize_to_limit
+        set_or_yell(@transformation, :width, args[0])
         set_or_yell(@transformation, :height, args[1])
         set_or_yell(@transformation, :crop, :limit)
-      when :resize_to_fit 
-        set_or_yell(@transformation, :width, args[0])    
+      when :resize_to_fit
+        set_or_yell(@transformation, :width, args[0])
         set_or_yell(@transformation, :height, args[1])
         set_or_yell(@transformation, :crop, :fit)
       when :resize_to_fill
-        set_or_yell(@transformation, :width, args[0])    
+        set_or_yell(@transformation, :width, args[0])
         set_or_yell(@transformation, :height, args[1])
         set_or_yell(@transformation, :gravity, args[2].to_s.downcase)
         set_or_yell(@transformation, :crop, :fill)
       when :resize_and_pad
-        set_or_yell(@transformation, :width, args[0])    
+        set_or_yell(@transformation, :width, args[0])
         set_or_yell(@transformation, :height, args[1])
         set_or_yell(@transformation, :background, args[2].to_s.downcase)
         set_or_yell(@transformation, :gravity, args[3].to_s.downcase)
         set_or_yell(@transformation, :crop, :pad)
-      when :scale 
-        set_or_yell(@transformation, :width, args[0])    
+      when :scale
+        set_or_yell(@transformation, :width, args[0])
         set_or_yell(@transformation, :height, args[1])
         set_or_yell(@transformation, :crop, :scale)
       when :crop
@@ -92,28 +100,28 @@ module Cloudinary::CarrierWave
         set_or_yell(@transformation, :crop, :crop)
       when :cloudinary_transformation
         args.each do
-          |attr, value|        
+          |attr, value|
           set_or_yell(@transformation, attr, value)
         end
       else
         if args.blank?
           send(name).each do
-            |attr, value|        
+            |attr, value|
             set_or_yell(@transformation, attr, value)
           end
         end
       end
     end
-    @transformation     
+    @transformation
   end
 
   def all_versions_processors
     all_versions = self.class.instance_variable_get('@all_versions')
-    
+
     all_versions ? all_versions.processors : []
   end
 
-  def all_processors    
+  def all_processors
     (self.is_main_uploader? ? [] : all_versions_processors) + self.class.processors
   end
 
@@ -126,22 +134,22 @@ module Cloudinary::CarrierWave
     raise CloudinaryException, "tags cannot be used in versions." if @tags.present? && self.version_name.present?
     @tags
   end
-  
+
   def format
     format_processor = self.all_processors.find{|processor| processor[0] == :convert}
-    if format_processor 
+    if format_processor
       # Explicit format is given
-      format = Array(format_processor[1]).first 
+      format = Array(format_processor[1]).first
     elsif self.transformation.include?(:format)
       format = self.transformation[:format]
-    elsif self.version_name.present? 
+    elsif self.version_name.present?
       # No local format. The reset should be handled by main uploader
       uploader = self.model.send(self.mounted_as)
       format = uploader.format
     else
       # Try to auto-detect format
       format = Cloudinary::PreloadedFile.split_format(original_filename || "").last
-      format ||= "png" # TODO Default format? 
+      format ||= "png" # TODO Default format?
     end
     format = format.to_s.downcase
     Cloudinary::FORMAT_ALIASES[format] || format

data/lib/cloudinary/uploader.rb

@@ -118,6 +118,7 @@ class Cloudinary::Uploader
         :backup=>options[:backup],
         :final=>options[:final],
         :part_number=>options[:part_number],
+        :tags=>options[:tags] && Cloudinary::Utils.build_array(options[:tags]).join(","),
         :upload_id=>options[:upload_id]
       }
       if file.is_a?(Pathname) || !file.respond_to?(:read)

data/lib/cloudinary/utils.rb

@@ -124,9 +124,17 @@ class Cloudinary::Utils
     shorten = config_option_consume(options, :shorten) 
     force_remote = options.delete(:force_remote)
     cdn_subdomain = config_option_consume(options, :cdn_subdomain) 
+    secure_cdn_subdomain = config_option_consume(options, :secure_cdn_subdomain) 
     sign_url = config_option_consume(options, :sign_url)
     secret = config_option_consume(options, :api_secret)
-    
+    sign_version = config_option_consume(options, :sign_version) # Deprecated behavior
+    url_suffix = options.delete(:url_suffix)
+    use_root_path = config_option_consume(options, :use_root_path)
+    if !private_cdn
+      raise(CloudinaryException, "URL Suffix only supported in private CDN") unless url_suffix.blank?
+      raise(CloudinaryException, "Root path only supported in private CDN") if use_root_path
+    end
+   
     original_source = source
     return original_source if source.blank?
     if defined?(CarrierWave::Uploader::Base) && source.is_a?(CarrierWave::Uploader::Base)
@@ -152,47 +160,107 @@ class Cloudinary::Utils
       end
     end
     
-    type ||= :upload
+    resource_type, type = finalize_resource_type(resource_type, type, url_suffix, use_root_path, shorten)
+    source, source_to_sign = finalize_source(source, format, url_suffix)
+    
+    version ||= 1 if source_to_sign.include?("/") and !source_to_sign.match(/^v[0-9]+/) and !source_to_sign.match(/^https?:\//)    
+    version &&= "v#{version}" 
+
+    transformation = transformation.gsub(%r(([^:])//), '\1/')
+    if sign_url
+      to_sign = [transformation, sign_version && version, source_to_sign].reject(&:blank?).join("/")
+      signature = 's--' + Base64.urlsafe_encode64(Digest::SHA1.digest(to_sign + secret))[0,8] + '--'
+    end
+
+    prefix = unsigned_download_url_prefix(source, cloud_name, private_cdn, cdn_subdomain, secure_cdn_subdomain, cname, secure, secure_distribution)
+    source = [prefix, resource_type, type, signature, transformation, version, source].reject(&:blank?).join("/")
+  end
 
+  def self.finalize_source(source, format, url_suffix)
+    source = source.gsub(%r(([^:])//), '\1/')
     if source.match(%r(^https?:/)i)
       source = smart_escape(source)
+      source_to_sign = source
     else
       source = smart_escape(URI.decode(source)) 
-      source = "#{source}.#{format}" if !format.blank?
+      source_to_sign = source
+      unless url_suffix.blank?
+        raise(CloudinaryException, "url_suffix should not include . or /") if url_suffix.match(%r([\./]))
+        source = "#{source}/#{url_suffix}" 
+      end
+      if !format.blank?
+        source = "#{source}.#{format}" 
+        source_to_sign = "#{source_to_sign}.#{format}" 
+      end
     end
+    [source, source_to_sign]
+  end    
 
-    if cloud_name.start_with?("/") # For development
-      prefix = "/res" + cloud_name
-    else 
-      shared_domain = !private_cdn
-      if secure        
-        if secure_distribution.nil? || secure_distribution == Cloudinary::OLD_AKAMAI_SHARED_CDN
-          secure_distribution = private_cdn ? "#{cloud_name}-res.cloudinary.com" : Cloudinary::SHARED_CDN
-        end
-        shared_domain ||= secure_distribution == Cloudinary::SHARED_CDN
-        prefix = "https://#{secure_distribution}"
+  def self.finalize_resource_type(resource_type, type, url_suffix, use_root_path, shorten)
+    type ||= :upload
+    if !url_suffix.blank?
+      if resource_type.to_s == "image" && type.to_s == "upload"
+        resource_type = "images"
+        type = nil
+      elsif resource_type.to_s == "raw" && type.to_s == "upload" 
+        resource_type = "files"
+        type = nil
       else
-        subdomain = cdn_subdomain ? "a#{(Zlib::crc32(source) % 5) + 1}." : ""
-        host = cname.blank? ? "#{private_cdn ? "#{cloud_name}-" : ""}res.cloudinary.com" : cname
-        prefix = "http://#{subdomain}#{host}"
+        raise(CloudinaryException, "URL Suffix only supported for image/upload and raw/upload")
+      end
+    end
+    if use_root_path
+      if (resource_type.to_s == "image" && type.to_s == "upload") || (resource_type.to_s == "images" && type.blank?)
+        resource_type = nil
+        type = nil
+      else
+        raise(CloudinaryException, "Root path only supported for image/upload")
       end
-      prefix += "/#{cloud_name}" if shared_domain
     end
-    
     if shorten && resource_type.to_s == "image" && type.to_s == "upload"
       resource_type = "iu"
       type = nil
     end
-    version ||= 1 if source.include?("/") and !source.match(/^v[0-9]+/) and !source.match(/^https?:\//)
-    
-    rest = [transformation, version ? "v#{version}" : nil, source].reject(&:blank?).join("/").gsub(%r(([^:])//), '\1/')
-    if sign_url
-      rest = 's--' + Base64.urlsafe_encode64(Digest::SHA1.digest(rest + secret))[0,8] + '--/' + rest
+    [resource_type, type]
+  end    
+  
+  # cdn_subdomain and secure_cdn_subdomain
+  # 1) Customers in shared distribution (e.g. res.cloudinary.com)
+  #   if cdn_domain is true uses res-[1-5].cloudinary.com for both http and https. Setting secure_cdn_subdomain to false disables this for https.
+  # 2) Customers with private cdn 
+  #   if cdn_domain is true uses cloudname-res-[1-5].cloudinary.com for http
+  #   if secure_cdn_domain is true uses cloudname-res-[1-5].cloudinary.com for https (please contact support if you require this)
+  # 3) Customers with cname
+  #   if cdn_domain is true uses a[1-5].cname for http. For https, uses the same naming scheme as 1 for shared distribution and as 2 for private distribution.
+  def self.unsigned_download_url_prefix(source, cloud_name, private_cdn, cdn_subdomain, secure_cdn_subdomain, cname, secure, secure_distribution)
+    return "/res#{cloud_name}" if cloud_name.start_with?("/") # For development
+
+    shared_domain = !private_cdn
+
+    if secure
+      if secure_distribution.nil? || secure_distribution == Cloudinary::OLD_AKAMAI_SHARED_CDN
+        secure_distribution = private_cdn ? "#{cloud_name}-res.cloudinary.com" : Cloudinary::SHARED_CDN
+      end
+      shared_domain ||= secure_distribution == Cloudinary::SHARED_CDN
+      secure_cdn_subdomain = cdn_subdomain if secure_cdn_subdomain.nil? && shared_domain
+
+      if secure_cdn_subdomain
+        secure_distribution = secure_distribution.gsub('res.cloudinary.com', "res-#{(Zlib::crc32(source) % 5) + 1}.cloudinary.com")
+      end
+
+      prefix = "https://#{secure_distribution}"
+    elsif cname
+      subdomain = cdn_subdomain ? "a#{(Zlib::crc32(source) % 5) + 1}." : ""
+      prefix = "http://#{subdomain}#{cname}"
+    else
+      host = [private_cdn ? "#{cloud_name}-" : "", "res", cdn_subdomain ? "-#{(Zlib::crc32(source) % 5) + 1}" : "", ".cloudinary.com"].join
+      prefix = "http://#{host}"        
     end
-    
-    source = prefix + "/" + [resource_type, type, rest].reject(&:blank?).join("/").gsub(%r(([^:])//), '\1/')
+    prefix += "/#{cloud_name}" if shared_domain
+
+    prefix
   end
-  
+
   def self.cloudinary_api_url(action = 'upload', options = {})
     cloudinary = options[:upload_prefix] || Cloudinary.config.upload_prefix || "https://api.cloudinary.com"
     cloud_name = options[:cloud_name] || Cloudinary.config.cloud_name || raise(CloudinaryException, "Must supply cloud_name")
@@ -239,7 +307,7 @@ class Cloudinary::Utils
   end
   
   def self.cloudinary_url(public_id, options = {})
-    if options[:type].to_s == 'authenticated'
+    if options[:type].to_s == 'authenticated' && !options[:sign_url]
       result = signed_download_url(public_id, options)
     else
       result = unsigned_download_url(public_id, options)

data/lib/cloudinary/version.rb

@@ -1,4 +1,4 @@
 # Copyright Cloudinary
 module Cloudinary
-  VERSION = "1.0.78"
+  VERSION = "1.0.79"
 end

data/spec/api_spec.rb

@@ -21,53 +21,53 @@ describe Cloudinary::Api do
   end
   
   it "should allow listing resource_types" do
-    @api.resource_types()["resource_types"].should include("image")
+    expect(@api.resource_types()["resource_types"]).to include("image")
   end
 
   it "should allow listing resources" do
     resource = @api.resources()["resources"].find{|resource| resource["public_id"] == "api_test"}
-    resource.should_not be_blank
-    resource["type"].should == "upload" 
+    expect(resource).not_to be_blank
+    expect(resource["type"]).to eq("upload")
   end
 
   it "should allow listing resources with cursor" do
     result = @api.resources(:max_results=>1)
-    result["resources"].should_not be_blank
-    result["resources"].length.should == 1
-    result["next_cursor"].should_not be_blank
+    expect(result["resources"]).not_to be_blank
+    expect(result["resources"].length).to eq(1)
+    expect(result["next_cursor"]).not_to be_blank
     result2 = @api.resources(:max_results=>1, :next_cursor=>result["next_cursor"])
-    result2["resources"].should_not be_blank
-    result2["resources"].length.should == 1
-    result2["resources"][0]["public_id"].should_not == result["resources"][0]["public_id"] 
+    expect(result2["resources"]).not_to be_blank
+    expect(result2["resources"].length).to eq(1)
+    expect(result2["resources"][0]["public_id"]).not_to eq(result["resources"][0]["public_id"] )
   end
 
 
   it "should allow listing resources by type" do
     resource = @api.resources(:type=>"upload", :tags=>true)["resources"].find{|resource| resource["public_id"] == "api_test"}
-    resource.should_not be_blank
-    resource["tags"].should == ["api_test_tag", @timestamp_tag]
+    expect(resource).not_to be_blank
+    expect(resource["tags"]).to eq(["api_test_tag", @timestamp_tag])
   end
 
   it "should allow listing resources by prefix" do
     resources = @api.resources(:type=>"upload", :prefix=>"api_test", :tags => true, :context => true)["resources"]
-    resources.map{|resource| resource["public_id"]}.should include("api_test", "api_test2")
-    resources.map{|resource| resource["tags"]}.should include(["api_test_tag", @timestamp_tag])
-    resources.map{|resource| resource["context"]}.should include({"custom" => {"key" => "value"}})
+    expect(resources.map{|resource| resource["public_id"]}).to include("api_test", "api_test2")
+    expect(resources.map{|resource| resource["tags"]}).to include(["api_test_tag", @timestamp_tag])
+    expect(resources.map{|resource| resource["context"]}).to include({"custom" => {"key" => "value"}})
   end
 
   it "should allow listing resources by tag" do
     resources = @api.resources_by_tag("api_test_tag", :tags => true, :context => true)["resources"]
-    resources.find{|resource| resource["public_id"] == "api_test"}.should_not be_blank
-    resources.map{|resource| resource["tags"]}.should include(["api_test_tag", @timestamp_tag])
-    resources.map{|resource| resource["context"]}.should include({"custom" => {"key" => "value"}})
+    expect(resources.find{|resource| resource["public_id"] == "api_test"}).not_to be_blank
+    expect(resources.map{|resource| resource["tags"]}).to include(["api_test_tag", @timestamp_tag])
+    expect(resources.map{|resource| resource["context"]}).to include({"custom" => {"key" => "value"}})
   end
   
   it "should allow listing resources by public ids" do
     resources = @api.resources_by_ids(["api_test", "api_test2"], :tags => true, :context => true)["resources"]
-    resources.length.should == 2
-    resources.find{|resource| resource["public_id"] == "api_test"}.should_not be_blank
-    resources.map{|resource| resource["tags"]}.should include(["api_test_tag", @timestamp_tag])
-    resources.map{|resource| resource["context"]}.should include({"custom" => {"key" => "value"}})
+    expect(resources.length).to eq(2)
+    expect(resources.find{|resource| resource["public_id"] == "api_test"}).not_to be_blank
+    expect(resources.map{|resource| resource["tags"]}).to include(["api_test_tag", @timestamp_tag])
+    expect(resources.map{|resource| resource["context"]}).to include({"custom" => {"key" => "value"}})
   end
   
   it "should allow listing resources by start date", :start_at => true do
@@ -76,7 +76,7 @@ describe Cloudinary::Api do
     sleep(2)
     response = Cloudinary::Uploader.upload("spec/logo.png")
     resources = @api.resources(:type=>"upload", :start_at=>start_at, :direction => "asc")["resources"]
-    resources.map{|resource| resource["public_id"]}.should == [response["public_id"]]
+    expect(resources.map{|resource| resource["public_id"]}) == [response["public_id"]]
   end
   
   it "should allow listing resources in both directions" do
@@ -84,132 +84,132 @@ describe Cloudinary::Api do
     desc_resources = @api.resources_by_tag(@timestamp_tag, :type=>"upload", :direction => "desc")["resources"]
     # NOTE: this assumes the full list fits in a page which is the case unless resources with 'api_test' prefix were
     # uploaded to the account against which this test runs
-    asc_resources.reverse.should == desc_resources
+    expect(asc_resources.reverse).to eq(desc_resources)
     asc_resources_alt = @api.resources_by_tag(@timestamp_tag, :type=>"upload", :direction => 1)["resources"]
     desc_resources_alt = @api.resources_by_tag(@timestamp_tag, :type=>"upload", :direction => -1)["resources"]
-    asc_resources_alt.reverse.should == desc_resources_alt
-    asc_resources.should == asc_resources_alt
-    lambda{@api.resources_by_tag(@timestamp_tag, :type=>"upload", :direction => "anythingelse")["resources"]}.should raise_error(Cloudinary::Api::BadRequest)
+    expect(asc_resources_alt.reverse).to eq(desc_resources_alt)
+    expect(asc_resources).to eq(asc_resources_alt)
+    expect{@api.resources_by_tag(@timestamp_tag, :type=>"upload", :direction => "anythingelse")["resources"]}.to raise_error(Cloudinary::Api::BadRequest)
   end
 
   it "should allow get resource metadata" do
     resource = @api.resource("api_test")
-    resource.should_not be_blank
-    resource["public_id"].should == "api_test"
-    resource["bytes"].should == 3381
-    resource["derived"].length.should == 1
+    expect(resource).not_to be_blank
+    expect(resource["public_id"]).to eq("api_test")
+    expect(resource["bytes"]).to eq(3381)
+    expect(resource["derived"].length).to eq(1)
   end
   
   it "should allow deleting derived resource" do
     Cloudinary::Uploader.upload("spec/logo.png", :public_id=>"api_test3", :eager=>[:width=>101,:crop=>:scale])
     resource = @api.resource("api_test3")
-    resource.should_not be_blank
-    resource["derived"].length.should == 1
+    expect(resource).not_to be_blank
+    expect(resource["derived"].length).to eq(1)
     derived_resource_id = resource["derived"][0]["id"]
     @api.delete_derived_resources(derived_resource_id)
     resource = @api.resource("api_test3")
-    resource.should_not be_blank
-    resource["derived"].length.should == 0
+    expect(resource).not_to be_blank
+    expect(resource["derived"].length).to eq(0)
   end
 
   it "should allow deleting resources" do
     Cloudinary::Uploader.upload("spec/logo.png", :public_id=>"api_test3")
     resource = @api.resource("api_test3")
-    resource.should_not be_blank
+    expect(resource).not_to be_blank
     @api.delete_resources(["apit_test", "api_test2", "api_test3"])
-    lambda{@api.resource("api_test3")}.should raise_error(Cloudinary::Api::NotFound)
+    expect{@api.resource("api_test3")}.to raise_error(Cloudinary::Api::NotFound)
   end
 
   it "should allow deleting resources by prefix" do
     Cloudinary::Uploader.upload("spec/logo.png", :public_id=>"api_test_by_prefix")
     resource = @api.resource("api_test_by_prefix")
-    resource.should_not be_blank
+    expect(resource).not_to be_blank
     @api.delete_resources_by_prefix("api_test_by")
-    lambda{@api.resource("api_test_by_prefix")}.should raise_error(Cloudinary::Api::NotFound)
+    expect{@api.resource("api_test_by_prefix")}.to raise_error(Cloudinary::Api::NotFound)
   end
 
   it "should allow deleting resources by tags" do
     Cloudinary::Uploader.upload("spec/logo.png", :public_id=>"api_test4", :tags=>["api_test_tag_for_delete"])
     resource = @api.resource("api_test4")
-    resource.should_not be_blank
+    expect(resource).not_to be_blank
     @api.delete_resources_by_tag("api_test_tag_for_delete")
-    lambda{@api.resource("api_test4")}.should raise_error(Cloudinary::Api::NotFound)
+    expect{@api.resource("api_test4")}.to raise_error(Cloudinary::Api::NotFound)
   end
 
   it "should allow listing tags" do
     tags = @api.tags()["tags"]
-    tags.should include('api_test_tag')
+    expect(tags).to include('api_test_tag')
   end
 
   it "should allow listing tag by prefix" do
     tags = @api.tags(:prefix=>"api_test")["tags"]
-    tags.should include('api_test_tag')
+    expect(tags).to include('api_test_tag')
     tags = @api.tags(:prefix=>"api_test_no_such_tag")["tags"]
-    tags.should be_blank
+    expect(tags).to be_blank
   end
   
   it "should allow listing transformations" do
     transformation = @api.transformations()["transformations"].find{|transformation| transformation["name"] == "c_scale,w_100"}
-    transformation.should_not be_blank
-    transformation["used"].should == true
+    expect(transformation).not_to be_blank
+    expect(transformation["used"]).to eq(true)
   end
 
   it "should allow getting transformation metadata" do
     transformation = @api.transformation("c_scale,w_100")
-    transformation.should_not be_blank  
-    transformation["info"].should == ["crop"=>"scale", "width"=>100]     
+    expect(transformation).not_to be_blank  
+    expect(transformation["info"]).to eq(["crop"=>"scale", "width"=>100]     )
     transformation = @api.transformation("crop"=>"scale", "width"=>100)
-    transformation.should_not be_blank  
-    transformation["info"].should == ["crop"=>"scale", "width"=>100]     
+    expect(transformation).not_to be_blank  
+    expect(transformation["info"]).to eq(["crop"=>"scale", "width"=>100]     )
   end
   
   it "should allow updating transformation allowed_for_strict" do
     @api.update_transformation("c_scale,w_100", :allowed_for_strict=>true)
     transformation = @api.transformation("c_scale,w_100")
-    transformation.should_not be_blank  
-    transformation["allowed_for_strict"].should == true
+    expect(transformation).not_to be_blank  
+    expect(transformation["allowed_for_strict"]).to eq(true)
     @api.update_transformation("c_scale,w_100", :allowed_for_strict=>false)
     transformation = @api.transformation("c_scale,w_100")
-    transformation.should_not be_blank  
-    transformation["allowed_for_strict"].should == false
+    expect(transformation).not_to be_blank  
+    expect(transformation["allowed_for_strict"]).to eq(false)
   end
 
   it "should allow creating named transformation" do
     @api.create_transformation("api_test_transformation", "crop"=>"scale", "width"=>102)
     transformation = @api.transformation("api_test_transformation")
-    transformation.should_not be_blank  
-    transformation["allowed_for_strict"].should == true
-    transformation["info"].should == ["crop"=>"scale", "width"=>102]
-    transformation["used"].should == false
+    expect(transformation).not_to be_blank  
+    expect(transformation["allowed_for_strict"]).to eq(true)
+    expect(transformation["info"]).to eq(["crop"=>"scale", "width"=>102])
+    expect(transformation["used"]).to eq(false)
   end
 
   it "should allow deleting named transformation" do
     @api.create_transformation("api_test_transformation2", "crop"=>"scale", "width"=>103)
     @api.transformation("api_test_transformation2")
     @api.delete_transformation("api_test_transformation2")
-    lambda{@api.transformation("api_test_transformation2")}.should raise_error(Cloudinary::Api::NotFound)
+    expect{@api.transformation("api_test_transformation2")}.to raise_error(Cloudinary::Api::NotFound)
   end  
 
   it "should allow unsafe update of named transformation" do
     @api.create_transformation("api_test_transformation3", "crop"=>"scale", "width"=>102)
     @api.update_transformation("api_test_transformation3", :unsafe_update=>{"crop"=>"scale", "width"=>103})
     transformation = @api.transformation("api_test_transformation3")
-    transformation.should_not be_blank  
-    transformation["info"].should == ["crop"=>"scale", "width"=>103]
-    transformation["used"].should == false
+    expect(transformation).not_to be_blank  
+    expect(transformation["info"]).to eq(["crop"=>"scale", "width"=>103])
+    expect(transformation["used"]).to eq(false)
   end
 
   it "should allow deleting implicit transformation" do
     @api.transformation("c_scale,w_100")
     @api.delete_transformation("c_scale,w_100")
-    lambda{@api.transformation("c_scale,w_100")}.should raise_error(Cloudinary::Api::NotFound)
+    expect{@api.transformation("c_scale,w_100")}.to raise_error(Cloudinary::Api::NotFound)
   end
   
   it "should allow creating and listing upload_presets", :upload_preset => true do
     @api.create_upload_preset(:name => "api_test_upload_preset", :folder => "folder")
     @api.create_upload_preset(:name => "api_test_upload_preset2", :folder => "folder2")
     @api.create_upload_preset(:name => "api_test_upload_preset3", :folder => "folder3")
-    @api.upload_presets["presets"].first(3).map{|p| p["name"]}.should == ["api_test_upload_preset3", "api_test_upload_preset2", "api_test_upload_preset"]
+    expect(@api.upload_presets["presets"].first(3).map{|p| p["name"]}).to eq(["api_test_upload_preset3", "api_test_upload_preset2", "api_test_upload_preset"])
     @api.delete_upload_preset("api_test_upload_preset")
     @api.delete_upload_preset("api_test_upload_preset2")
     @api.delete_upload_preset("api_test_upload_preset3")
@@ -219,12 +219,12 @@ describe Cloudinary::Api do
     result = @api.create_upload_preset(:unsigned => true, :folder => "folder", :width => 100, :crop => :scale, :tags => ["a","b","c"], :context => {:a => "b", :c => "d"})
     name = result["name"]
     preset = @api.upload_preset(name)
-    preset["name"].should == name
-    preset["unsigned"].should == true
-    preset["settings"]["folder"].should == "folder"
-    preset["settings"]["transformation"].should == [{"width" => 100, "crop" => "scale"}]
-    preset["settings"]["context"].should == {"a" => "b", "c" => "d"}
-    preset["settings"]["tags"].should == ["a","b","c"]
+    expect(preset["name"]).to eq(name)
+    expect(preset["unsigned"]).to eq(true)
+    expect(preset["settings"]["folder"]).to eq("folder")
+    expect(preset["settings"]["transformation"]).to eq([{"width" => 100, "crop" => "scale"}])
+    expect(preset["settings"]["context"]).to eq({"a" => "b", "c" => "d"})
+    expect(preset["settings"]["tags"]).to eq(["a","b","c"])
     @api.delete_upload_preset(name)
   end
   
@@ -232,7 +232,7 @@ describe Cloudinary::Api do
     @api.create_upload_preset(:name => "api_test_upload_preset4", :folder => "folder")
     preset = @api.upload_preset("api_test_upload_preset4")
     @api.delete_upload_preset("api_test_upload_preset4")
-    lambda{preset = @api.upload_preset("api_test_upload_preset4")}.should raise_error
+    expect{preset = @api.upload_preset("api_test_upload_preset4")}.to raise_error
   end
   
   it "should allow updating upload_presets", :upload_preset => true do
@@ -240,9 +240,9 @@ describe Cloudinary::Api do
     preset = @api.upload_preset(name)
     @api.update_upload_preset(name, preset["settings"].merge(:colors => true, :unsigned => true, :disallow_public_id => true))
     preset = @api.upload_preset(name)
-    preset["name"].should == name
-    preset["unsigned"].should == true
-    preset["settings"].should == {"folder" => "folder", "colors" => true, "disallow_public_id" => true}
+    expect(preset["name"]).to eq(name)
+    expect(preset["unsigned"]).to eq(true)
+    expect(preset["settings"]).to eq({"folder" => "folder", "colors" => true, "disallow_public_id" => true})
     @api.delete_upload_preset(name)
   end
   
@@ -250,41 +250,41 @@ describe Cloudinary::Api do
   it "should allow deleting all resources", :delete_all=>true do
     Cloudinary::Uploader.upload("spec/logo.png", :public_id=>"api_test5", :eager=>[:width=>101,:crop=>:scale])
     resource = @api.resource("api_test5")
-    resource.should_not be_blank
-    resource["derived"].length.should == 1
+    expect(resource).not_to be_blank
+    expect(resource["derived"].length).to eq(1)
     @api.delete_all_resources(:keep_original => true)
     resource = @api.resource("api_test5")
-    resource.should_not be_blank
-    resource["derived"].length.should == 0
+    expect(resource).not_to be_blank
+    expect(resource["derived"].length).to eq(0)
   end
   
   it "should support setting manual moderation status" do
     result = Cloudinary::Uploader.upload("spec/logo.png", {:moderation => :manual})
-    result["moderation"][0]["status"].should == "pending"
-    result["moderation"][0]["kind"].should == "manual"
+    expect(result["moderation"][0]["status"]).to eq("pending")
+    expect(result["moderation"][0]["kind"]).to eq("manual")
     api_result = Cloudinary::Api.update(result["public_id"], {:moderation_status => :approved})
-    api_result["moderation"][0]["status"].should == "approved"
-    api_result["moderation"][0]["kind"].should == "manual"
+    expect(api_result["moderation"][0]["status"]).to eq("approved")
+    expect(api_result["moderation"][0]["kind"]).to eq("manual")
   end
     
   it "should support requesting raw conversion" do
     result = Cloudinary::Uploader.upload("spec/docx.docx", :resource_type => :raw)
-    lambda{Cloudinary::Api.update(result["public_id"], {:resource_type => :raw, :raw_convert => :illegal})}.should raise_error(Cloudinary::Api::BadRequest, /^Illegal value|not a valid/)
+    expect{Cloudinary::Api.update(result["public_id"], {:resource_type => :raw, :raw_convert => :illegal})}.to raise_error(Cloudinary::Api::BadRequest, /^Illegal value|not a valid/)
   end
   
   it "should support requesting categorization" do
     result = Cloudinary::Uploader.upload("spec/logo.png")
-    lambda{Cloudinary::Api.update(result["public_id"], {:categorization => :illegal})}.should raise_error(Cloudinary::Api::BadRequest, /^Illegal value/)
+    expect{Cloudinary::Api.update(result["public_id"], {:categorization => :illegal})}.to raise_error(Cloudinary::Api::BadRequest, /^Illegal value/)
   end
   
   it "should support requesting detection" do
     result = Cloudinary::Uploader.upload("spec/logo.png")
-    lambda{Cloudinary::Api.update(result["public_id"], {:detection => :illegal})}.should raise_error(Cloudinary::Api::BadRequest, /^Illegal value/)
+    expect{Cloudinary::Api.update(result["public_id"], {:detection => :illegal})}.to raise_error(Cloudinary::Api::BadRequest, /^Illegal value/)
   end
   
   it "should support requesting auto_tagging" do
     result = Cloudinary::Uploader.upload("spec/logo.png")
-    lambda{Cloudinary::Api.update(result["public_id"], {:auto_tagging => 0.5})}.should raise_error(Cloudinary::Api::BadRequest, /^Must use/)
+    expect{Cloudinary::Api.update(result["public_id"], {:auto_tagging => 0.5})}.to raise_error(Cloudinary::Api::BadRequest, /^Must use/)
   end
   
   it "should support listing by moderation kind and value" do
@@ -294,17 +294,34 @@ describe Cloudinary::Api do
     Cloudinary::Api.update(result1["public_id"], {:moderation_status => :approved})
     Cloudinary::Api.update(result2["public_id"], {:moderation_status => :rejected})
     approved = Cloudinary::Api.resources_by_moderation(:manual, :approved, :max_results => 1000)["resources"].map{|r| r["public_id"]}
-    approved.should include(result1["public_id"])
-    approved.should_not include(result2["public_id"])
-    approved.should_not include(result3["public_id"])
+    expect(approved).to include(result1["public_id"])
+    expect(approved).not_to include(result2["public_id"])
+    expect(approved).not_to include(result3["public_id"])
     rejected = Cloudinary::Api.resources_by_moderation(:manual, :rejected, :max_results => 1000)["resources"].map{|r| r["public_id"]}
-    rejected.should include(result2["public_id"])
-    rejected.should_not include(result1["public_id"])
-    rejected.should_not include(result3["public_id"])
+    expect(rejected).to include(result2["public_id"])
+    expect(rejected).not_to include(result1["public_id"])
+    expect(rejected).not_to include(result3["public_id"])
     pending = Cloudinary::Api.resources_by_moderation(:manual, :pending, :max_results => 1000)["resources"].map{|r| r["public_id"]}
-    pending.should include(result3["public_id"])
-    pending.should_not include(result1["public_id"])
-    pending.should_not include(result2["public_id"])
+    expect(pending).to include(result3["public_id"])
+    expect(pending).not_to include(result1["public_id"])
+    expect(pending).not_to include(result2["public_id"])
   end
 
+  it "should support listing folders" do
+    pending("For this test to work, 'Auto-create folders' should be enabled in the Upload Settings, " + 
+            "and the account should be empty of folders. " +
+            "Comment out this line if you really want to test it.")
+    Cloudinary::Uploader.upload("spec/logo.png", {:public_id => "test_folder1/item"})
+    Cloudinary::Uploader.upload("spec/logo.png", {:public_id => "test_folder2/item"})
+    Cloudinary::Uploader.upload("spec/logo.png", {:public_id => "test_folder1/test_subfolder1/item"})
+    Cloudinary::Uploader.upload("spec/logo.png", {:public_id => "test_folder1/test_subfolder2/item"})
+    result = Cloudinary::Api.root_folders
+    expect(result["folders"][0]["name"]).to eq("test_folder1")
+    expect(result["folders"][1]["name"]).to eq("test_folder2")
+    result = Cloudinary::Api.subfolders("test_folder1")
+    expect(result["folders"][0]["path"]).to eq("test_folder1/test_subfolder1")
+    expect(result["folders"][1]["path"]).to eq("test_folder1/test_subfolder2")
+    expect{Cloudinary::Api.subfolders("test_folder")}.to raise_error(Cloudinary::Api::NotFound)
+    Cloudinary::Api.delete_resources_by_prefix("test_folder")
+  end
 end