cloudinary 1.1.1 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ffc7266645b3ced1d9e812359e5465c092a5d235
-  data.tar.gz: c88363381e77a8b0d564ff5166de4f3dce2d719a
+  metadata.gz: 0434852c7adc610fb1cf86057bff3e1e4691bae2
+  data.tar.gz: c930430f7658ebba0eb73fc97496d2aaaff84892
 SHA512:
-  metadata.gz: b0260293a3726a9e27105b5175cc6f9502e85e15c55e20f8d8fe128cff3a0401ce74dc2301d03184cf0494635a6ac30c47b85257806f713a21b48f7232de1e85
-  data.tar.gz: ebd11eb3dd9abe5f2e0c9ec30360c455a758d2bc4b0084989ed68d3d6af4cb0804b4d3725e38b92388b8d733560edc928e8326dd9afc5c5ce35821ef3e08bed5
+  metadata.gz: f912c8645358d41d2b69f0ddfde69915e98cfe0221a3f8ce583b83d3f2d936416c23a31f8c3951ec1776a051e13cc04a44d6500034ca8641d5d50b2e4e0bf76d
+  data.tar.gz: 19d6c8c6f0bde05cabbb57565a66eb0fb70a8648daa959c2602c7d012ece530af032fdb012669b1f7f8da78e70f8c69189ce17e2f5033be327d271e06d354749

data/CHANGELOG.md

@@ -1,4 +1,36 @@
 
+1.1.2 / 2015-12-16
+==================
+
+  * Support new archive (ZIP) creation API:
+    * Uploader: `create_archive`, `create_zip`.
+    * Utils: `download_archive_url`, `download_zip_url`
+    * Helper: `cl_download_archive_url`, `cl_download_zip_url`.
+  * Use basic to_query implementation when Rails is not available.
+  * Allow chained transformations and eager transformations to process width & height when crop is not defined.
+  * Apply style and whitespaces.
+  * Remove redundant variable. Replace if ! with until.
+  * Apply style and whitespaces.
+  * Remove redundant variable
+  * Add `:invalidate` option to `Cloudinary::Uploader.rename`
+  * Add line spacing to text layer
+  * Add upload mapping
+  * Add `Cloudinary::Api.restore`
+  * Add `deep_hash_values` matcher. Add `invalidate` test to `explicit`
+  * Add `Cloudinary.user_platform`
+  * Merge branch 'feature/breakpoints_and_zip'
+  * Add test for `Cloudinary::Uploader.create_zip`
+  * Refactor `create_archive`. Rename `generate_zip_download_url`. Create `download_archive_url`. Add cleanup to spec code.
+  * Add condition to `image_tag` and `image_path` aliasing.
+  * Add `archive_spec.rb`. Add rubyzip development dependency.
+  * Add `Cloudinary::` to `Utils` calls
+  * Fix temp file name in spec. Re-enable deletion of resources after the test.
+  * Add deprecation warning to `zip_download_url`
+  * Fix rake `build` dependency to `cloudinary:fetch_assets`
+  * Apply `symbolize_keys`
+  * Support the aspect_ratio transformation parameter
+  * Support responsive_breakpoints JSON parameter in upload and explicit API
+
 1.1.1 / 2015-12-04
 ==================
 

data/cloudinary.gemspec

@@ -23,6 +23,7 @@ Gem::Specification.new do |s|
   s.add_dependency "aws_cf_signer"
   s.add_development_dependency "rspec", '>=3.2'
   s.add_development_dependency "rspec-rails"
+  s.add_development_dependency "rubyzip"
 
   if RUBY_VERSION > "1.9"
     s.add_dependency "rest-client"

data/lib/cloudinary.rb

@@ -23,8 +23,27 @@ module Cloudinary
   OLD_AKAMAI_SHARED_CDN = "cloudinary-a.akamaihd.net"
   SHARED_CDN = AKAMAI_SHARED_CDN
   
-  USER_AGENT = "cld-ruby-" + VERSION
-    
+  USER_AGENT = "CloudinaryRuby/" + VERSION
+  @@user_platform = ""
+
+  # Add platform information to the USER_AGENT header
+  # This is intended for platform information and not individual applications!
+  def self.user_platform=(value)
+    @@user_platform= value
+  end
+
+  def self.user_platform
+    @@user_platform
+  end
+
+  def self.USER_AGENT
+    if @@user_platform.empty?
+      "#{USER_AGENT}"
+    else
+      "#{@@user_platform} #{USER_AGENT}"
+    end
+  end
+
   FORMAT_ALIASES = {
     "jpeg" => "jpg",
     "jpe" => "jpg",

data/lib/cloudinary/api.rb

@@ -8,165 +8,173 @@ class Cloudinary::Api
   class RateLimited < Error; end
   class BadRequest < Error; end
   class GeneralError < Error; end
-  class AuthorizationRequired < Error; end 
+  class AuthorizationRequired < Error; end
   class Response < Hash
     attr_reader :rate_limit_reset_at, :rate_limit_remaining, :rate_limit_allowed
+
     def initialize(response)
       self.update(Cloudinary::Api.send(:parse_json_response, response))
-      @rate_limit_allowed = response.headers[:x_featureratelimit_limit].to_i
-      @rate_limit_reset_at = Time.parse(response.headers[:x_featureratelimit_reset])
-      @rate_limit_remaining = response.headers[:x_featureratelimit_remaining].to_i     
+      @rate_limit_allowed   = response.headers[:x_featureratelimit_limit].to_i
+      @rate_limit_reset_at  = Time.parse(response.headers[:x_featureratelimit_reset])
+      @rate_limit_remaining = response.headers[:x_featureratelimit_remaining].to_i
     end
   end
 
   def self.ping(options={})
     call_api(:get, "ping", {}, options)
   end
-  
+
   def self.usage(options={})
     call_api(:get, "usage", {}, options)
   end
-  
+
   def self.resource_types(options={})
     call_api(:get, "resources", {}, options)
   end
 
   def self.resources(options={})
     resource_type = options[:resource_type] || "image"
-    type = options[:type]
-    uri = "resources/#{resource_type}"
-    uri += "/#{type}" if !type.blank?
-    call_api(:get, uri, only(options, :next_cursor, :max_results, :prefix, :tags, :context, :moderations, :direction, :start_at), options)    
+    type          = options[:type]
+    uri           = "resources/#{resource_type}"
+    uri           += "/#{type}" unless type.blank?
+    call_api(:get, uri, only(options, :next_cursor, :max_results, :prefix, :tags, :context, :moderations, :direction, :start_at), options)
   end
-  
+
   def self.resources_by_tag(tag, options={})
     resource_type = options[:resource_type] || "image"
-    uri = "resources/#{resource_type}/tags/#{tag}"
-    call_api(:get, uri, only(options, :next_cursor, :max_results, :tags, :context, :moderations, :direction), options)    
+    uri           = "resources/#{resource_type}/tags/#{tag}"
+    call_api(:get, uri, only(options, :next_cursor, :max_results, :tags, :context, :moderations, :direction), options)
   end
-  
+
   def self.resources_by_moderation(kind, status, options={})
     resource_type = options[:resource_type] || "image"
-    uri = "resources/#{resource_type}/moderations/#{kind}/#{status}"
-    call_api(:get, uri, only(options, :next_cursor, :max_results, :tags, :context, :moderations, :direction), options)    
+    uri           = "resources/#{resource_type}/moderations/#{kind}/#{status}"
+    call_api(:get, uri, only(options, :next_cursor, :max_results, :tags, :context, :moderations, :direction), options)
   end
-  
+
   def self.resources_by_ids(public_ids, options={})
     resource_type = options[:resource_type] || "image"
-    type = options[:type] || "upload"
-    uri = "resources/#{resource_type}/#{type}"
+    type          = options[:type] || "upload"
+    uri           = "resources/#{resource_type}/#{type}"
     call_api(:get, uri, only(options, :tags, :context, :moderations).merge(:public_ids => public_ids), options)
   end
-  
+
   def self.resource(public_id, options={})
     resource_type = options[:resource_type] || "image"
-    type = options[:type] || "upload"
-    uri = "resources/#{resource_type}/#{type}/#{public_id}"
-    call_api(:get, uri, only(options, :colors, :exif, :faces, :image_metadata, :pages, :phash, :coordinates, :max_results), options)      
+    type          = options[:type] || "upload"
+    uri           = "resources/#{resource_type}/#{type}/#{public_id}"
+    call_api(:get, uri, only(options, :colors, :exif, :faces, :image_metadata, :pages, :phash, :coordinates, :max_results), options)
   end
-  
-  def self.update(public_id, options={})
+
+  def self.restore(public_ids, options={})
     resource_type = options[:resource_type] || "image"
-    type = options[:type] || "upload"
-    uri = "resources/#{resource_type}/#{type}/#{public_id}"
+    type          = options[:type] || "upload"
+    uri           = "resources/#{resource_type}/#{type}/restore"
+    call_api(:post, uri, { :public_ids => public_ids }, options)
+  end
+
+  def self.update(public_id, options={})
+    resource_type  = options[:resource_type] || "image"
+    type           = options[:type] || "upload"
+    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]),
-      :face_coordinates => Cloudinary::Utils.encode_double_array(options[:face_coordinates]),
+      :tags               => options[:tags] && Cloudinary::Utils.build_array(options[:tags]).join(","),
+      :context            => Cloudinary::Utils.encode_hash(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],
-      :raw_convert => options[:raw_convert],
-      :ocr => options[:ocr],
-      :categorization => options[:categorization],
-      :detection => options[:detection],
-      :similarity_search => options[:similarity_search],
+      :moderation_status  => options[:moderation_status],
+      :raw_convert        => options[:raw_convert],
+      :ocr                => options[:ocr],
+      :categorization     => options[:categorization],
+      :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
     }
     call_api(:post, uri, update_options, options)
   end
-  
+
   def self.delete_resources(public_ids, options={})
     resource_type = options[:resource_type] || "image"
-    type = options[:type] || "upload"    
-    uri = "resources/#{resource_type}/#{type}"
-    call_api(:delete, uri, {:public_ids=>public_ids}.merge(only(options, :keep_original, :invalidate)), options)      
+    type          = options[:type] || "upload"
+    uri           = "resources/#{resource_type}/#{type}"
+    call_api(:delete, uri, { :public_ids => public_ids }.merge(only(options, :keep_original, :invalidate)), options)
   end
 
   def self.delete_resources_by_prefix(prefix, options={})
     resource_type = options[:resource_type] || "image"
-    type = options[:type] || "upload"    
-    uri = "resources/#{resource_type}/#{type}"
-    call_api(:delete, uri, {:prefix=>prefix}.merge(only(options, :keep_original, :next_cursor, :invalidate)), options)      
+    type          = options[:type] || "upload"
+    uri           = "resources/#{resource_type}/#{type}"
+    call_api(:delete, uri, { :prefix => prefix }.merge(only(options, :keep_original, :next_cursor, :invalidate)), options)
   end
-  
+
   def self.delete_all_resources(options={})
     resource_type = options[:resource_type] || "image"
-    type = options[:type] || "upload"    
-    uri = "resources/#{resource_type}/#{type}"
-    call_api(:delete, uri, {:all=>true}.merge(only(options, :keep_original, :next_cursor, :invalidate)), options)      
+    type          = options[:type] || "upload"
+    uri           = "resources/#{resource_type}/#{type}"
+    call_api(:delete, uri, { :all => true }.merge(only(options, :keep_original, :next_cursor, :invalidate)), options)
   end
-  
+
   def self.delete_resources_by_tag(tag, options={})
     resource_type = options[:resource_type] || "image"
-    uri = "resources/#{resource_type}/tags/#{tag}"
-    call_api(:delete, uri, only(options, :keep_original, :next_cursor, :invalidate), options)    
+    uri           = "resources/#{resource_type}/tags/#{tag}"
+    call_api(:delete, uri, only(options, :keep_original, :next_cursor, :invalidate), options)
   end
-  
+
   def self.delete_derived_resources(derived_resource_ids, options={})
     uri = "derived_resources"
-    call_api(:delete, uri, {:derived_resource_ids=>derived_resource_ids}, options)      
+    call_api(:delete, uri, { :derived_resource_ids => derived_resource_ids }, options)
   end
 
   def self.tags(options={})
     resource_type = options[:resource_type] || "image"
-    uri = "tags/#{resource_type}"
-    call_api(:get, uri, only(options, :next_cursor, :max_results, :prefix), options)    
+    uri           = "tags/#{resource_type}"
+    call_api(:get, uri, only(options, :next_cursor, :max_results, :prefix), options)
   end
-  
+
   def self.transformations(options={})
-    call_api(:get, "transformations", only(options, :next_cursor, :max_results), options)    
+    call_api(:get, "transformations", only(options, :next_cursor, :max_results), options)
   end
 
   def self.transformation(transformation, options={})
-    call_api(:get, "transformations/#{transformation_string(transformation)}", only(options, :max_results), options)    
+    call_api(:get, "transformations/#{transformation_string(transformation)}", only(options, :max_results), options)
   end
-  
+
   def self.delete_transformation(transformation, options={})
-    call_api(:delete, "transformations/#{transformation_string(transformation)}", {}, options)    
+    call_api(:delete, "transformations/#{transformation_string(transformation)}", {}, options)
   end
-  
+
   # updates - supports:
   #   "allowed_for_strict" boolean
   #   "unsafe_update" transformation params - updates a named transformation parameters without regenerating existing images
   def self.update_transformation(transformation, updates, options={})
-    params = only(updates, :allowed_for_strict)
+    params                 = only(updates, :allowed_for_strict)
     params[:unsafe_update] = transformation_string(updates[:unsafe_update]) if updates[:unsafe_update]
     call_api(:put, "transformations/#{transformation_string(transformation)}", params, options)
   end
-  
+
   def self.create_transformation(name, definition, options={})
-    call_api(:post, "transformations/#{name}", {:transformation=>transformation_string(definition)}, options)
+    call_api(:post, "transformations/#{name}", { :transformation => transformation_string(definition) }, options)
   end
-  
+
   # upload presets
   def self.upload_presets(options={})
-    call_api(:get, "upload_presets", only(options, :next_cursor, :max_results), options)    
+    call_api(:get, "upload_presets", only(options, :next_cursor, :max_results), options)
   end
 
   def self.upload_preset(name, options={})
     call_api(:get, "upload_presets/#{name}", only(options, :max_results), options)
   end
-  
+
   def self.delete_upload_preset(name, options={})
-    call_api(:delete, "upload_presets/#{name}", {}, options)    
+    call_api(:delete, "upload_presets/#{name}", {}, options)
   end
-  
+
   def self.update_upload_preset(name, options={})
     params = Cloudinary::Uploader.build_upload_params(options)
     call_api(:put, "upload_presets/#{name}", params.merge(only(options, :unsigned, :disallow_public_id)), options)
   end
-  
+
   def self.create_upload_preset(options={})
     params = Cloudinary::Uploader.build_upload_params(options)
     call_api(:post, "upload_presets", params.merge(only(options, :name, :unsigned, :disallow_public_id)), options)
@@ -179,55 +187,79 @@ class Cloudinary::Api
   def self.subfolders(of_folder_path, options={})
     call_api(:get, "folders/#{of_folder_path}", {}, options)
   end
-  
+
+  def self.upload_mappings(options={})
+    params = only(options, :next_cursor, :max_results)
+    call_api(:get, :upload_mappings, params, options)
+  end
+
+  def self.upload_mapping(name=nil, options={})
+    call_api(:get, 'upload_mappings', { :folder => name }, options)
+  end
+
+  def self.delete_upload_mapping(name, options={})
+    call_api(:delete, 'upload_mappings', { :folder => name }, options)
+  end
+
+  def self.update_upload_mapping(name, options={})
+    params          = only(options, :template)
+    params[:folder] = name
+    call_api(:put, 'upload_mappings', params, options)
+  end
+
+  def self.create_upload_mapping(name, options={})
+    params          = only(options, :template)
+    params[:folder] = name
+    call_api(:post, 'upload_mappings', params, options)
+  end
+
   protected
-  
+
   def self.call_api(method, uri, params, options)
     cloudinary = options[:upload_prefix] || Cloudinary.config.upload_prefix || "https://api.cloudinary.com"
     cloud_name = options[:cloud_name] || Cloudinary.config.cloud_name || raise("Must supply cloud_name")
-    api_key = options[:api_key] || Cloudinary.config.api_key || raise("Must supply api_key")
+    api_key    = options[:api_key] || Cloudinary.config.api_key || raise("Must supply api_key")
     api_secret = options[:api_secret] || Cloudinary.config.api_secret || raise("Must supply api_secret")
-    timeout = options[:timeout] || Cloudinary.config.timeout || 60
-    api_url = [cloudinary, "v1_1", cloud_name, uri].join("/")
+    timeout    = options[:timeout] || Cloudinary.config.timeout || 60
+    api_url    = [cloudinary, "v1_1", cloud_name, uri].join("/")
     # Add authentication
     api_url.sub!(%r(^(https?://)), "\\1#{api_key}:#{api_secret}@")
-    
-    RestClient::Request.execute(:method => method, :url => api_url, :payload => params.reject{|k, v| v.nil? || v==""}, :timeout=> timeout, :headers => {"User-Agent" => Cloudinary::USER_AGENT}) do
-      |response, request, tmpresult|
+
+    RestClient::Request.execute(:method => method, :url => api_url, :payload => params.reject { |k, v| v.nil? || v=="" }, :timeout => timeout, :headers => { "User-Agent" => Cloudinary::USER_AGENT }) do
+    |response, request, tmpresult|
       return Response.new(response) if response.code == 200
       exception_class = case response.code
-        when 400 then BadRequest
-        when 401 then AuthorizationRequired
-        when 403 then NotAllowed
-        when 404 then NotFound
-        when 409 then AlreadyExists
-        when 420 then RateLimited
-        when 500 then GeneralError
-        else raise GeneralError.new("Server returned unexpected status code - #{response.code} - #{response.body}")   
+      when 400 then BadRequest
+      when 401 then AuthorizationRequired
+      when 403 then NotAllowed
+      when 404 then NotFound
+      when 409 then AlreadyExists
+      when 420 then RateLimited
+      when 500 then GeneralError
+      else raise GeneralError.new("Server returned unexpected status code - #{response.code} - #{response.body}")
       end
       json = parse_json_response(response)
       raise exception_class.new(json["error"]["message"])
-    end    
+    end
   end
-  
+
   def self.parse_json_response(response)
     return Cloudinary::Utils.json_decode(response.body)
   rescue => e
     # Error is parsing json
     raise GeneralError.new("Error parsing server response (#{response.code}) - #{response.body}. Got - #{e}")
   end
-  
+
   def self.only(hash, *keys)
     result = {}
-    keys.each do
-      |key| 
+    keys.each do |key|
       result[key] = hash[key] if hash.include?(key)
       result[key] = hash[key.to_s] if hash.include?(key.to_s)
     end
     result
-  end  
-  
+  end
+
   def self.transformation_string(transformation)
-    transformation = transformation.is_a?(String) ? transformation : Cloudinary::Utils.generate_transformation_string(transformation.clone)
+    transformation.is_a?(String) ? transformation : Cloudinary::Utils.generate_transformation_string(transformation.clone)
   end
 end

data/lib/cloudinary/helper.rb

@@ -236,10 +236,23 @@ module CloudinaryHelper
     Cloudinary::Utils.private_download_url(public_id, format, options)
   end
 
+  # Helper method that uses the deprecated ZIP download API. 
+  # Replaced by cl_download_zip_url that uses the more advanced and robust archive generation and download API
+  # @deprecated
   def cl_zip_download_url(tag, options = {})
     Cloudinary::Utils.zip_download_url(tag, options)
   end
 
+  # @see {Cloudinary::Utils.download_archive_url}
+  def cl_download_archive_url(options = {})
+    Cloudinary::Utils.download_archive_url(options)
+  end  
+
+  # @see {Cloudinary::Utils.download_zip_url}
+  def cl_download_zip_url(options = {})
+    Cloudinary::Utils.download_zip_url(options)
+  end
+
   def cl_signed_download_url(public_id, options = {})
     Cloudinary::Utils.signed_download_url(public_id, options)
   end
@@ -251,11 +264,11 @@ module CloudinaryHelper
         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 # defines image_tag_without_cloudinary
-        alias_method_chain :image_path, :cloudinary # defines image_path_without_cloudinary
+        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
-        alias_method :image_path_without_cloudinary, :image_path
+        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
     end
   end