cloudinary 1.0.68 → 1.0.69

data/CHANGELOG

@@ -1,3 +1,12 @@
+= Version 1.0.69 - 2014-02-25
+  * Admin API update method.
+  * Admin API listing by moderation kind and status.
+  * Support moderation status in admin API listing.
+  * Support moderation flag in upload. 
+  * New upload and update API parameters: moderation, ocr, raw_conversion, categorization, detection, similarity_search and auto_tagging.
+  * Allow CloudinaryHelper to be included into standalone classes.
+  * Added support for Sequel models using CarrierWave.
+
 = Version 1.0.68 - 2014-02-16
   * Support for uploading large raw files.
   * Correct support for image_tag and image_path override.

data/lib/cloudinary/api.rb

@@ -36,20 +36,26 @@ class Cloudinary::Api
     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, :direction), options)    
+    call_api(:get, uri, only(options, :next_cursor, :max_results, :prefix, :tags, :context, :moderations, :direction), 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, :direction), options)    
+    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)    
   end
   
   def self.resources_by_ids(public_ids, options={})
     resource_type = options[:resource_type] || "image"
     type = options[:type] || "upload"
     uri = "resources/#{resource_type}/#{type}"
-    call_api(:get, uri, only(options, :tags, :context).merge(:public_ids => public_ids), options)
+    call_api(:get, uri, only(options, :tags, :context, :moderations).merge(:public_ids => public_ids), options)
   end
   
   def self.resource(public_id, options={})
@@ -59,6 +65,25 @@ class Cloudinary::Api
     call_api(:get, uri, only(options, :colors, :exif, :faces, :image_metadata, :pages, :max_results), 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]),
+      :moderation_status => options[:moderation_status],
+      :raw_convert => options[:raw_convert],
+      :ocr => options[:ocr],
+      :categorization => options[:categorization],
+      :detection => options[:detection],
+      :similarity_search => options[:similarity_search],
+      :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"    

data/lib/cloudinary/carrier_wave/storage.rb

@@ -64,6 +64,11 @@ class Cloudinary::CarrierWave::Storage < ::CarrierWave::Storage::Abstract
     store_cloudinary_identifier(version, filename)
   end
 
+  # Updates the model mounter identifier with version information.
+  #
+  # Carrierwave uses hooks when integrating with ORMs so it's important to
+  # update the identifier in a way that does not trigger hooks again or else
+  # you'll get stuck in a loop.
   def store_cloudinary_identifier(version, filename)
     name = "v#{version}/#{filename}"
     model_class = uploader.model.class
@@ -83,11 +88,14 @@ class Cloudinary::CarrierWave::Storage < ::CarrierWave::Storage::Abstract
       else
         uploader.model.set(column, name)
       end
+    elsif defined?(Sequel::Model) && uploader.model.is_a?(Sequel::Model)
+      # Sequel support
+      uploader.model.this.update(column => name)
     elsif model_class.respond_to?(:update_all) && uploader.model.respond_to?(:_id)
       model_class.where(:_id=>uploader.model._id).update_all(column=>name)
       uploader.model.send :write_attribute, column, name
     else
-      raise CloudinaryException, "Only ActiveRecord and Mongoid are supported at the moment!"
+      raise CloudinaryException, "Only ActiveRecord, Mongoid and Sequel are supported at the moment!"
     end
   end
 end

data/lib/cloudinary/helper.rb

@@ -195,6 +195,9 @@ module CloudinaryHelper
   def self.included(base)
     ActionView::Helpers::FormBuilder.send(:include, Cloudinary::FormBuilder)
     base.class_eval do
+      if !method_defined?(:image_tag)
+        include ActionView::Helpers::AssetTagHelper
+      end
       if defined?(Rails) && !Rails.version.start_with?("2") && Cloudinary.config.enhance_image_tag
         alias_method_chain :image_tag, :cloudinary
         alias_method_chain :image_path, :cloudinary

data/lib/cloudinary/uploader.rb

@@ -38,10 +38,17 @@ class Cloudinary::Uploader
               :eager_async=>Cloudinary::Utils.as_safe_bool(options[:eager_async]),
               :proxy=>options[:proxy],
               :folder=>options[:folder],
+              :allowed_formats =>  Cloudinary::Utils.build_array(options[:allowed_formats]).join(","),
               :tags=>options[:tags] && Cloudinary::Utils.build_array(options[:tags]).join(","),
-              :allowed_formats =>  Cloudinary::Utils.build_array(options[:allowed_formats]).join(","),
               :context => Cloudinary::Utils.encode_hash(options[:context]),
-              :face_coordinates => Cloudinary::Utils.encode_double_array(options[:face_coordinates])}    
+              :face_coordinates => Cloudinary::Utils.encode_double_array(options[:face_coordinates]),
+              :moderation => options[:moderation],
+              :raw_convert => options[:raw_convert],
+              :ocr => options[:ocr],
+              :categorization => options[:categorization],
+              :detection => options[:detection],
+              :similarity_search => options[:similarity_search],
+              :auto_tagging => options[:auto_tagging] && options[:auto_tagging].to_f}    
     params    
   end
    
@@ -59,44 +66,44 @@ class Cloudinary::Uploader
     end              
   end
 
-  # Upload large raw files. Note that public_id should include an extension for best results.
-  def self.upload_large(file, public_id, options={})
-    if file.is_a?(Pathname) || !file.respond_to?(:read)
-      file = File.open(file, "rb")
-    end
-    upload = upload_id = nil
-    index = 1
-    while !file.eof?
-      buffer = file.read(20_000_000)
-      upload = upload_large_part(Cloudinary::Blob.new(buffer), public_id, options.merge(:upload_id=>upload_id, :part_number=>index, :final=>file.eof?))
-      upload_id = upload["upload_id"]      
-      index += 1
-    end
-    upload
-  end
-    
-
-  # Upload large raw files. Note that public_id should include an extension for best results.
-  def self.upload_large_part(file, public_id, options={})
-    call_api("upload_large", options.merge(:resource_type=>:raw)) do    
-      params = {
-        :timestamp=>Time.now.to_i,
-        :type=>options[:type],
-        :public_id=> public_id,
-        :backup=>options[:backup],
-        :final=>options[:final],
-        :part_number=>options[:part_number],
-        :upload_id=>options[:upload_id]
-      }
-      if file.is_a?(Pathname) || !file.respond_to?(:read)
-        params[:file] = File.open(file, "rb")
-      else
-        params[:file] = file
-      end
-      [params, [:file]]
-    end              
-  end
-
+  # Upload large raw files. Note that public_id should include an extension for best results.
+  def self.upload_large(file, public_id, options={})
+    if file.is_a?(Pathname) || !file.respond_to?(:read)
+      file = File.open(file, "rb")
+    end
+    upload = upload_id = nil
+    index = 1
+    while !file.eof?
+      buffer = file.read(20_000_000)
+      upload = upload_large_part(Cloudinary::Blob.new(buffer), public_id, options.merge(:upload_id=>upload_id, :part_number=>index, :final=>file.eof?))
+      upload_id = upload["upload_id"]      
+      index += 1
+    end
+    upload
+  end
+    
+
+  # Upload large raw files. Note that public_id should include an extension for best results.
+  def self.upload_large_part(file, public_id, options={})
+    call_api("upload_large", options.merge(:resource_type=>:raw)) do    
+      params = {
+        :timestamp=>Time.now.to_i,
+        :type=>options[:type],
+        :public_id=> public_id,
+        :backup=>options[:backup],
+        :final=>options[:final],
+        :part_number=>options[:part_number],
+        :upload_id=>options[:upload_id]
+      }
+      if file.is_a?(Pathname) || !file.respond_to?(:read)
+        params[:file] = File.open(file, "rb")
+      else
+        params[:file] = file
+      end
+      [params, [:file]]
+    end              
+  end
+  
   def self.destroy(public_id, options={})
     call_api("destroy", options) do    
       {

data/lib/cloudinary/version.rb

@@ -1,4 +1,4 @@
 # Copyright Cloudinary
 module Cloudinary
-  VERSION = "1.0.68"
+  VERSION = "1.0.69"
 end

data/spec/api_spec.rb

@@ -202,5 +202,59 @@ describe Cloudinary::Api do
     resource.should_not be_blank
     resource["derived"].length.should == 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"
+    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"
+  end
+  
+  it "should support requesting ocr info" do
+    result = Cloudinary::Uploader.upload("spec/logo.png")
+    lambda{Cloudinary::Api.update(result["public_id"], {:ocr => :illegal})}.should raise_error(Cloudinary::Api::BadRequest, /^Illegal value/)
+  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/)
+  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/)
+  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/)
+  end
+  
+  it "should support requesting ocr info" 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/)
+  end
+  
+  it "should support listing by moderation kind and value" do
+    result1 = Cloudinary::Uploader.upload("spec/logo.png", {:moderation => :manual})
+    result2 = Cloudinary::Uploader.upload("spec/logo.png", {:moderation => :manual})
+    result3 = Cloudinary::Uploader.upload("spec/logo.png", {:moderation => :manual})
+    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"])
+    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"])
+    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"])
+  end
 
 end

data/spec/uploader_spec.rb

@@ -70,34 +70,34 @@ describe Cloudinary::Uploader do
   end
   
   it "should correctly handle unique_filename" do
-    result = Cloudinary::Uploader.upload("spec/logo.png", use_filename: true)
+    result = Cloudinary::Uploader.upload("spec/logo.png", :use_filename => true)
     result["public_id"].should match(/logo_[a-zA-Z0-9]{6}/)
-    result = Cloudinary::Uploader.upload("spec/logo.png", use_filename: true, unique_filename: false)
+    result = Cloudinary::Uploader.upload("spec/logo.png", :use_filename => true, :unique_filename => false)
     result["public_id"].should  == "logo"
   end
   
   it "should allow whitelisted formats if allowed_formats", :allowed=>true do
-    result = Cloudinary::Uploader.upload("spec/logo.png", allowed_formats: ["png"])
+    result = Cloudinary::Uploader.upload("spec/logo.png", :allowed_formats => ["png"])
     result["format"].should == "png"
   end
   
   it "should prevent non whitelisted formats from being uploaded if allowed_formats is specified", :allowed=>true do
-    lambda{Cloudinary::Uploader.upload("spec/logo.png", allowed_formats: ["jpg"])}.should raise_error
+    lambda{Cloudinary::Uploader.upload("spec/logo.png", :allowed_formats => ["jpg"])}.should raise_error
   end
   
   it "should allow non whitelisted formats if type is specified and convert to that type", :allowed=>true do
-    result = Cloudinary::Uploader.upload("spec/logo.png", allowed_formats: ["jpg"], format: "jpg")
+    result = Cloudinary::Uploader.upload("spec/logo.png", :allowed_formats => ["jpg"], :format => "jpg")
     result["format"].should == "jpg"
   end
   
   it "should allow sending face coordinates" do
     coordinates = [[120, 30, 109, 150], [121, 31, 110, 151]]
-    result = Cloudinary::Uploader.upload("spec/logo.png", {face_coordinates: coordinates, faces: true})
+    result = Cloudinary::Uploader.upload("spec/logo.png", {:face_coordinates => coordinates, :faces => true})
     result["faces"].should == coordinates
 
     different_coordinates = [[122, 32, 111, 152]]
-    Cloudinary::Uploader.explicit(result["public_id"], {face_coordinates: different_coordinates, faces: true, type: "upload"})
-    info = Cloudinary::Api.resource(result["public_id"], {faces: true})
+    Cloudinary::Uploader.explicit(result["public_id"], {:face_coordinates => different_coordinates, :faces => true, :type => "upload"})
+    info = Cloudinary::Api.resource(result["public_id"], {:faces => true})
     info["faces"].should == different_coordinates
   end
   
@@ -107,4 +107,30 @@ describe Cloudinary::Uploader do
     info = Cloudinary::Api.resource(result["public_id"], {:context => true})
     info["context"].should == {"custom" => context}
   end
+  
+  it "should support requesting manual moderation" do
+    result = Cloudinary::Uploader.upload("spec/logo.png", {:moderation => :manual})
+    result["moderation"][0]["status"].should == "pending"
+    result["moderation"][0]["kind"].should == "manual"
+  end
+  
+  it "should support requesting ocr info" do
+    lambda{Cloudinary::Uploader.upload("spec/logo.png", {:ocr => :illegal})}.should raise_error(CloudinaryException, /Illegal value/)
+  end
+  
+  it "should support requesting raw conversion" do
+    lambda{Cloudinary::Uploader.upload("spec/docx.docx", {:resource_type => :raw, :raw_convert => :illegal})}.should raise_error(CloudinaryException, /Illegal value/)
+  end
+  
+  it "should support requesting categorization" do
+    lambda{Cloudinary::Uploader.upload("spec/logo.png", {:categorization => :illegal})}.should raise_error(CloudinaryException, /Illegal value/)
+  end
+  
+  it "should support requesting detection" do
+    lambda{Cloudinary::Uploader.upload("spec/logo.png", {:detection => :illegal})}.should raise_error(CloudinaryException, /Illegal value/)
+  end
+  
+  it "should support requesting auto_tagging" do
+    lambda{Cloudinary::Uploader.upload("spec/logo.png", {:auto_tagging => 0.5})}.should raise_error(CloudinaryException, /Must use/)
+  end
 end

data/spec/utils_spec.rb

@@ -441,23 +441,23 @@ describe Cloudinary::Utils do
   end
   
   it "should correctly sign URLs", :signed => true do
-    options = {version: 1234, transformation: {crop: "crop", width: 10, height: 20}, sign_url: true}
+    options = {:version => 1234, :transformation => {:crop => "crop", :width => 10, :height => 20}, :sign_url => true}
     expected = "http://res.cloudinary.com/test123/image/upload/s--MaRXzoEC--/c_crop,h_20,w_10/v1234/image.jpg"
     actual = Cloudinary::Utils.cloudinary_url("image.jpg", options)
     actual.should == expected
     
-    options = {version: 1234, sign_url: true}
+    options = {:version => 1234, :sign_url => true}
     expected = "http://res.cloudinary.com/test123/image/upload/s--ZlgFLQcO--/v1234/image.jpg"
     actual = Cloudinary::Utils.cloudinary_url("image.jpg", options)
     actual.should == expected
     
-    options = {transformation: {crop: "crop", width: 10, height: 20}, sign_url: true}
+    options = {:transformation => {:crop => "crop", :width => 10, :height => 20}, :sign_url => true}
     expected = "http://res.cloudinary.com/test123/image/upload/s--Ai4Znfl3--/c_crop,h_20,w_10/image.jpg"
     actual = Cloudinary::Utils.cloudinary_url("image.jpg", options)
     actual.should == expected
     
     expected = "http://res.cloudinary.com/test123/image/fetch/s--_GAUclyB--/v1234/http://google.com/path/to/image.png"
-    actual = Cloudinary::Utils.cloudinary_url("http://google.com/path/to/image.png", type: "fetch", version: 1234, sign_url: true)
+    actual = Cloudinary::Utils.cloudinary_url("http://google.com/path/to/image.png", :type => "fetch", :version => 1234, :sign_url => true)
     actual.should == expected    
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cloudinary
 version: !ruby/object:Gem::Version
-  version: 1.0.68
+  version: 1.0.69
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-16 00:00:00.000000000 Z
+date: 2014-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -101,6 +101,7 @@ files:
 - lib/cloudinary/version.rb
 - lib/tasks/cloudinary.rake
 - spec/api_spec.rb
+- spec/docx.docx
 - spec/favicon.ico
 - spec/logo.png
 - spec/spec_helper.rb
@@ -145,6 +146,7 @@ specification_version: 3
 summary: Client library for easily using the Cloudinary service
 test_files:
 - spec/api_spec.rb
+- spec/docx.docx
 - spec/favicon.ico
 - spec/logo.png
 - spec/spec_helper.rb