cloudinary 1.0.0

data/.gitignore

@@ -0,0 +1,4 @@
+pkg
+.project
+.rvmrc
+

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in cloudinary.gemspec
+gemspec

data/README.md

@@ -0,0 +1,46 @@
+Cloudinary
+==========
+
+Cloudinary allows web applications to manage web resources in the cloud leveraging cloud-solutions. 
+Cloudinary offers a solution to the entire asset management workflow, from upload to transformations, optimizations, storage and delivery. 
+
+## Setup ######################################################################
+
+To install the Cloudinary Ruby GEM, run:
+
+	$ gem install cloudinary
+
+I you use Rails 3.x or higher, edit your Gemfile, add the following line and run 'bundle'
+
+	$ gem 'cloudinary'
+
+Or in Rails 2.x, edit your environment.rb and add:
+
+	$ config.gem 'cloudinary'
+
+If you would like to use our optional integration module of image uploads with ActiveRecord using CarrierWave, install CarrierWave to:
+
+	$ gem install carrierwave
+
+Rails 3.x Gemfile:
+
+	$ gem 'carrierwave'
+
+Rails 2.x environment.rb
+
+	$ config.gem 'carrierwave', :version => '~> 0.4.1'
+
+
+## Usage ######################################################################
+
+Refer to Cloudinary Documentation at:
+http://cloudinary.com/documentation
+
+
+For documetation about Ruby on Rails integration see:
+http://cloudinary.com/documentation/rails_integration
+
+
+## License #######################################################################
+
+Released under the MIT license. 

data/Rakefile

@@ -0,0 +1,3 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+

data/cloudinary.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cloudinary/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cloudinary"
+  s.version     = Cloudinary::VERSION
+  s.authors     = ["Nadav Soferman","Itai Lahan","Tal Lev-Ami"]
+  s.email       = ["nadav.soferman@cloudinary.com","itai.lahan@cloudinary.com","tal.levami@cloudinary.com"]
+  s.homepage    = "http://cloudinary.com"
+  s.summary     = %q{Client library for easily using the Cloudinary service}
+  s.description = %q{Client library for easily using the Cloudinary service}
+
+  s.rubyforge_project = "cloudinary"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_dependency "rest-client"
+end

data/lib/cloudinary.rb

@@ -0,0 +1,85 @@
+# Copyright Cloudinary
+require "ostruct"
+require "cloudinary/version"
+require "cloudinary/utils"
+require "cloudinary/uploader"
+require "cloudinary/downloader"
+require "cloudinary/migrator"  
+require "cloudinary/blob" 
+require 'active_support' 
+if defined?(::CarrierWave)
+  require "cloudinary/carrier_wave"
+end  
+
+if defined?(::ActionView::Base)
+  require "cloudinary/helper"  
+end
+
+if !nil.respond_to?(:blank?)
+class Object
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+end
+
+class NilClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class FalseClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class TrueClass #:nodoc:
+  def blank?
+    false
+  end
+end
+
+class Array #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class Hash #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class String #:nodoc:
+  def blank?
+    self !~ /\S/
+  end
+end
+
+class Numeric #:nodoc:
+  def blank?
+    false
+  end
+end  
+end
+
+module Cloudinary  
+  @@config = nil
+  
+  def self.config(new_config=nil)    
+    @@config = new_config if new_config
+    if block_given?
+      @@config = OpenStruct.new
+      yield(@@config)
+    end 
+    # Heroku support
+    if @@config.nil? && ENV["CLOUDINARY_CLOUD_NAME"]
+      @@config = OpenStruct.new(
+        "cloud_name" => ENV["CLOUDINARY_CLOUD_NAME"],
+        "api_key" => ENV["CLOUDINARY_API_KEY"],
+        "api_secret" => ENV["CLOUDINARY_API_SECRET"],
+        "secure_distribution" => ENV["CLOUDINARY_SECURE_DISTRIBUTION"],
+        "private_cdn" => ENV["CLOUDINARY_PRIVATE_CDN"].to_s == 'true'
+      )
+    end    
+    @@config ||= OpenStruct.new((YAML.load_file(Rails.root.join("config").join("cloudinary.yml"))[Rails.env] rescue {}))
+  end
+end

data/lib/cloudinary/blob.rb

@@ -0,0 +1,11 @@
+# Copyright Cloudinary
+class Cloudinary::Blob < StringIO
+  attr_reader :original_filename, :content_type
+  alias_method :path, :original_filename
+  
+  def initialize(data, options={})
+    super(data)
+    @original_filename = options[:original_filename] || "cloudinaryfile"
+    @content_type = options[:content_type] || "application/octet-stream"
+  end
+end

data/lib/cloudinary/carrier_wave.rb

@@ -0,0 +1,228 @@
+# Copyright Cloudinary
+require 'pp'
+module Cloudinary::CarrierWave
+  class UploadError < StandardError
+    attr_reader :http_code
+    def initialize(message, http_code)
+      super(message)
+      @http_code = http_code
+    end
+  end
+  
+  module ClassMethods
+    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    
+
+    def scale(width, height)
+      process :scale => [width, height]
+    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
+  end
+  
+  def self.included(base)
+    base.storage Cloudinary::CarrierWave::Storage
+    base.extend ClassMethods
+    base.send(:attr_accessor, :metadata)
+  end
+  
+  def set_or_yell(hash, attr, value)
+    raise "conflicting transformation on #{attr} #{value}!=#{hash[attr]}" if hash[attr]
+    hash[attr] = value
+  end
+  
+  def transformation
+    return @transformation if @transformation
+    transformation = {}
+    self.class.processors.each do
+      |name, args|
+      case name
+      when :convert # Do nothing. This is handled by format
+      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])    
+        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, :height, args[1])
+        set_or_yell(transformation, :gravity, args[2].to_s.downcase)
+        set_or_yell(transformation, :crop, :fill)
+      when :resize_to_pad
+        set_or_yell(transformation, :width, args[0])    
+        set_or_yell(transformation, :height, args[1])
+        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])    
+        set_or_yell(transformation, :height, args[1])
+        set_or_yell(transformation, :crop, :scale)
+      when :crop
+        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, :crop)
+      when :cloudinary_transformation
+        args.each do
+          |attr, value|        
+          set_or_yell(transformation, attr, value)
+        end
+      end
+    end
+    @transformation = transformation
+    @transformation     
+  end
+  
+  def eager
+    @eager ||= self.class.processors.any?{|processor| processor[0] == :eager}
+  end
+
+  def tags
+    @tags ||= self.class.processors.select{|processor| processor[0] == :tags}.map(&:last).first
+  end
+  
+  def format
+    format_processor = self.class.processors.find{|processor| processor[0] == :convert}
+    if format_processor
+      if format_processor[1].is_a?(Array)
+        return format_processor[1][0]
+      end  
+      return format_processor[1]
+    end
+    the_filename = original_filename || stored_filename
+    return the_filename.split(".").last if the_filename.include?(".")
+    "png" # TODO Default format?
+  end
+  
+  def url(*args)
+    if(args.first)
+      super
+    else
+      options = self.class.version_names.blank? ? {} : self.transformation
+      Cloudinary::Utils.cloudinary_url(self.my_filename, options.clone)
+    end
+  end
+
+  def process!(new_file=nil)
+    # Do nothing
+  end
+
+  def stored_filename
+    @stored_filename ||= model.read_uploader(mounted_as)
+  end  
+
+  def my_filename
+    @my_filename ||= stored_filename || ("#{self.public_id}.#{self.format}")
+  end
+    
+  def public_id
+    return @public_id if @public_id
+    if stored_filename
+      last_dot = stored_filename.rindex(".")
+      @public_id = last_dot ? stored_filename[0, last_dot] : stored_filename 
+    end    
+    @public_id ||= Cloudinary::Utils.random_public_id
+  end  
+  
+  def download!(uri)
+    uri = process_uri(uri)
+    self.original_filename = @cache_id = @filename = File.basename(uri.path).gsub(/[^a-zA-Z0-9\.\-\+_]/, '')
+    @file = RemoteFile.new(uri, @filename)
+  end
+  
+  def blank?
+    self.filename.blank? && self.stored_filename.blank?
+  end
+  
+  class RemoteFile
+    attr_reader :uri, :original_filename
+    def initialize(uri, filename)
+      @uri = uri
+      @original_filename = filename
+    end
+    
+    def delete
+      # Do nothing. This is a virtual file.
+    end
+  end
+  
+  class Storage < ::CarrierWave::Storage::Abstract
+    def store!(file)
+      # Moved to identifier...
+      if uploader.class.version_names.blank?
+        # This is the toplevel, need to upload the actual file.     
+        params = uploader.transformation.dup
+        params[:return_error] = true
+        params[:format] = uploader.format
+        params[:public_id] = uploader.public_id.split("/").last
+        params[:tags] = uploader.tags if uploader.tags 
+        eager_versions = uploader.versions.values.select(&:eager)
+        params[:eager] = eager_versions.map{|version| [version.transformation, version.format]} if eager_versions.length > 0
+        
+        data = nil
+        if (file.is_a?(RemoteFile))
+          data = file.uri.to_s
+        else
+          data = file.file
+          data.rewind if !file.is_path? && data.respond_to?(:rewind)
+        end
+        uploader.metadata = Cloudinary::Uploader.upload(data, params)
+        if uploader.metadata["error"]
+          raise UploadError.new(uploader.metadata["error"]["message"], uploader.metadata["error"]["http_code"])
+        end
+        
+        if uploader.metadata["version"]
+          raise "Only ActiveRecord supported at the moment!" if !(uploader.model.class.respond_to?(:update_all) && uploader.model.class.respond_to?(:primary_key))
+          primary_key = uploader.model.class.primary_key.to_sym
+          uploader.model.class.update_all(["#{uploader.mounted_as}=?", "v#{uploader.metadata["version"]}/#{identifier.split("/").last}"], {primary_key=>uploader.model.send(primary_key)})
+        end
+        # Will throw an exception on error
+      else
+        raise "nested versions are not allowed." if (uploader.class.version_names.length > 1)
+        # Do nothing
+      end
+    end
+    
+    def retrieve!(identifier)
+      # Do nothing
+    end 
+    
+    def identifier
+      (uploader.filename || uploader.stored_filename) ? uploader.my_filename : nil
+    end   
+  end
+end

data/lib/cloudinary/downloader.rb

@@ -0,0 +1,21 @@
+# Copyright Cloudinary
+class Cloudinary::Downloader
+  
+  def self.download(source, options={})
+    options = options.clone
+    if !source.match(/^https?:\/\//i)
+      source = Cloudinary::Utils.cloudinary_url(source, options)
+    end
+    
+    url = URI.parse(source) 
+    http = Net::HTTP.new(url.host, url.port)
+    req = Net::HTTP::Get.new(url.path)
+    if url.port == 443
+      http.use_ssl=true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end  
+    res = http.start{|agent| agent.request(req)}
+    return res.body        
+  end
+    
+end

data/lib/cloudinary/helper.rb

@@ -0,0 +1,53 @@
+# Copyright Cloudinary
+
+module CloudinaryHelper  
+  # Examples
+  # cl_image_tag "israel.png", :width=>100, :height=>100, :alt=>"hello" # W/H are not sent to cloudinary
+  # cl_image_tag "israel.png", :width=>100, :height=>100, :alt=>"hello", :crop=>:fit # W/H are sent to cloudinary
+  def cl_image_tag(source, options = {})
+    options = options.clone
+    source = cloudinary_url(source, options)
+    options[:width] = options.delete(:html_width) if options.include?(:html_width)
+    options[:height] = options.delete(:html_height) if options.include?(:html_height)
+
+    image_tag(source, options)
+  end
+  
+  def facebook_profile_image_tag(profile, options = {})    
+    cl_image_tag(profile, {:type=>:facebook}.merge(options))
+  end
+
+  def twitter_profile_image_tag(profile, options = {})    
+    cl_image_tag(profile, {:type=>:twitter}.merge(options))
+  end
+
+  def twitter_name_profile_image_tag(profile, options = {})    
+    cl_image_tag(profile, {:type=>:twitter_name}.merge(options))
+  end
+
+  def cl_sprite_url(source, options = {})
+    options = options.clone
+    
+    version_store = options.delete(:version_store)
+    if options[:version].blank? && (version_store == :file) && defined?(Rails) && defined?(Rails.root)
+      file_name = "#{Rails.root}/tmp/cloudinary/cloudinary_sprite_#{source.sub(/\..*/, '')}.version"
+      if File.exists?(file_name)
+        options[:version] = File.read(file_name).chomp        
+      end
+    end  
+    
+    options[:format] = "css" unless source.ends_with?(".css")
+    cloudinary_url(source, options.merge(:type=>:sprite))
+  end
+
+  def cl_sprite_tag(source, options = {})
+    stylesheet_link_tag(cl_sprite_url(source, options))
+  end
+
+  def cloudinary_url(source, options = {})
+    options[:secure] = request.ssl? if !options.include?(:secure) && defined?(request) && request && request.respond_to?(:ssl?)
+    Cloudinary::Utils.cloudinary_url(source, options)
+  end  
+end
+
+ActionView::Base.send :include, CloudinaryHelper

data/lib/cloudinary/helpers.rb

@@ -0,0 +1,7 @@
+# Copyright Cloudinary
+
+module CloudinaryHelper
+    
+end
+
+ActionView::Base.send :include, CloudinaryHelper

data/lib/cloudinary/migrator.rb

@@ -0,0 +1,361 @@
+# Copyright Cloudinary
+
+class Cloudinary::Migrator
+  attr_reader :retrieve, :complete
+  attr_accessor :terminate, :in_process
+  attr_reader :db
+  attr_reader :work, :results, :mutex
+  attr_reader :extra_options
+  
+  
+  @@init = false
+  def self.init
+    return if @@init
+    @@init = true
+
+    begin 
+      require 'sqlite3'
+    rescue LoadError
+      raise "Please add sqlite3 to your Gemfile"    
+    end
+    require 'tempfile'
+  end
+  
+  def json_decode(str)
+    Cloudinary::Utils.json_decode(str)
+  end
+    
+  def initialize(options={})
+    self.class.init
+    
+    options[:db_file] = "tmp/migration#{$$}.db" if options[:private_database] && !options[:db_file] 
+    @dbfile = options[:db_file] || "tmp/migration.db"
+    FileUtils.mkdir_p(File.dirname(@dbfile))
+    @db = SQLite3::Database.new @dbfile, :results_as_hash=>true
+    @retrieve = options[:retrieve]
+    @complete = options[:complete]
+    @debug = options[:debug] || false
+    @ignore_duplicates = options[:ignore_duplicates]
+    @threads = [options[:threads] || 10, 100].min
+    @extra_options = {:api_key=>options[:api_key], :api_secret=>options[:api_secret]}
+    @delete_after_done = options[:delete_after_done] || options[:private_database]
+    @max_processing = @threads * 10
+    @in_process = 0
+    @work = Queue.new
+    @results = Queue.new
+    @mutex = Mutex.new
+    @db.execute "
+      create table if not exists queue (
+        id integer primary key,
+        internal_id integer,
+        public_id text,
+        url text,
+        metadata text,
+        result string,
+        status text,
+        updated_at integer
+      )
+    "
+    @db.execute "
+      create index if not exists status_idx on queue (
+        status
+      )
+    "
+    @db.execute "
+      create unique index if not exists internal_id_idx on queue (
+        internal_id
+      )
+    "
+    @db.execute "
+      create unique index if not exists public_id_idx on queue (
+        public_id
+      )
+    "
+    if options[:reset_queue]
+      @db.execute("delete from queue")
+    end
+  end
+    
+  def register_retrieve(&block)
+    @retrieve = block
+  end
+
+  def register_complete(&block)
+    @complete = block
+  end
+  
+  def process(options={})    
+    raise "url not given and no retieve callback given" if options[:url].nil? && self.retrieve.nil?
+    raise "id not given and retieve or complete callback given" if options[:id].nil? && (!self.retrieve.nil? || !self.complete.nil?)
+
+    debug("Process: #{options.inspect}")
+    start
+    process_results    
+    wait_for_queue
+    options = options.dup
+    id = options.delete(:id)
+    url = options.delete(:url)
+    public_id = options.delete(:public_id)
+    row = {
+      "internal_id"=>id, 
+      "url"=>url, 
+      "public_id"=>public_id, 
+      "metadata"=>options.to_json,
+      "status"=>"processing"      
+    }    
+    begin
+      insert_row(row)
+      add_to_work_queue(row)
+    rescue SQLite3::ConstraintException
+      raise if !@ignore_duplicates
+    end
+  end
+      
+  def done
+    start
+    process_all_pending
+    @terminate = true
+    1.upto(@threads){self.work << nil} # enough objects to release all waiting threads
+    @started = false
+    @db.close
+    File.delete(@dbfile) if @delete_after_done
+  end
+  
+  def max_given_id
+    db.get_first_value("select max(internal_id) from queue").to_i
+  end
+  
+  def close_if_needed(file)
+    if file.nil?
+      # Do nothing.
+    elsif file.respond_to?(:close!) 
+      file.close! 
+    elsif file.respond_to?(:close)
+      file.close
+    end
+  rescue
+    # Ignore errors in closing files
+  end  
+
+  def temporary_file(data, filename)  
+    file = RUBY_VERSION == "1.8.7" ? Tempfile.new('cloudinary') : Tempfile.new('cloudinary', :encoding => 'ascii-8bit')
+    file.unlink
+    file.write(data)
+    file.rewind
+    # Tempfile return path == nil after unlink, which break rest-client              
+    class << file
+      attr_accessor :original_filename
+      def content_type
+        "application/octet-stream"                  
+      end
+    end
+    file.original_filename = filename
+    file                  
+  end
+
+  private
+
+  def update_all(values)
+    @db.execute("update queue set #{values.keys.map{|key| "#{key}=?"}.join(",")}", *values.values)
+  end
+  
+  def update_row(row, values)    
+    values.merge!("updated_at"=>Time.now.to_i)
+    query = ["update queue set #{values.keys.map{|key| "#{key}=?"}.join(",")} where id=?"] + values.values + [row["id"]]
+    result = @db.execute(*query)
+    values.each{|key, value| row[key.to_s] = value}
+    row    
+  end
+  
+  def insert_row(values)
+    values.merge!("updated_at"=>Time.now.to_i)
+    @db.execute("insert into queue (#{values.keys.join(",")}) values (#{values.keys.map{"?"}.join(",")})", *values.values)
+    values["id"] = @db.last_insert_row_id
+  end
+  
+  def refill_queue(last_id)
+    @db.execute("select * from queue where status in ('error', 'processing') and id > ? limit ?", last_id, 10000) do
+      |row|
+      last_id = row["id"] if row["id"] > last_id
+      wait_for_queue
+      add_to_work_queue(row)
+    end
+    last_id
+  end 
+
+  def process_results
+    while self.results.length > 0
+      row = self.results.pop
+      result = json_decode(row["result"])      
+      debug("Done ID=#{row['internal_id']}, result=#{result.inspect}")
+      complete.call(row["internal_id"], result) if complete 
+      if result["error"]        
+        status = case result["error"]["http_code"]
+        when 400, 404 then "fatal" # Problematic request. Not a server problem.
+        else "error"
+        end
+      else
+        status = "completed"
+      end       
+      updates = {:status=>status, :result=>row["result"]}
+      updates["public_id"] = result["public_id"] if result["public_id"] && !row["public_id"]
+      begin 
+        update_row(row, updates)
+      rescue SQLite3::ConstraintException
+        updates = {:status=>"error", :result=>{:error=>{:message=>"public_id already exists"}}.to_json}
+        update_row(row, updates)
+      end
+    end
+  end
+
+  def try_try_again(tries=5)
+    retry_count = 0
+    begin
+      return yield
+    rescue
+      retry_count++
+      raise if retry_count > tries
+      sleep rand * 3
+      retry
+    end  
+  end
+  
+  def start
+    return if @started
+    @started = true
+    @terminate = false
+    
+    self.work.clear
+    
+    main = self
+    Thread.abort_on_exception = true
+    1.upto(@threads) do
+      |i|
+      Thread.start do
+        while !main.terminate
+          file = nil
+          row = main.work.pop
+          next if row.nil?
+          begin
+            debug "Thread #{i} - processing row #{row.inspect}. #{main.work.length} work waiting. #{main.results.length} results waiting."
+            url = row["url"]
+            cw = false
+            result = nil
+            if url.nil? && !self.retrieve.nil?
+              data = self.retrieve.call(row["internal_id"])
+              if defined?(ActiveRecord::Base) && data.is_a?(ActiveRecord::Base)
+                cw = true
+                data.save!
+              elsif defined?(Cloudinary::CarrierWave) && data.is_a?(Cloudinary::CarrierWave)
+                cw = true
+                begin
+                  data.model.save! 
+                rescue Cloudinary::CarrierWave::UploadError 
+                  # upload errors will be handled by the result values.
+                end
+                result = data.metadata
+              elsif data.respond_to?(:read) && data.respond_to?(:path)
+                # This is an IO style object, pass as is.
+                file = data
+              elsif !data.nil?
+                file = main.temporary_file(data, row["public_id"] || "cloudinaryfile") 
+              end
+            end
+            
+            if url || file
+              options = main.extra_options.merge(:public_id=>row["public_id"])
+              json_decode(row["metadata"]).each do
+                |key, value|
+                options[key.to_sym] = value
+              end
+                          
+              result = Cloudinary::Uploader.upload(url || file, options.merge(:return_error=>true)) || ({:error=>{:message=>"Received nil from uploader!"}})
+            elsif cw
+              result ||= {"status" => "saved"}
+            else
+              result = {"error" => {"message" => "Empty data and url", "http_code"=>404}} 
+            end
+            main.results << {"id"=>row["id"], "internal_id"=>row["internal_id"], "result"=>result.to_json}
+          rescue => e
+            $stderr.print "Thread #{i} - Error in processing row #{row.inspect} - #{e}\n"
+            debug(e.backtrace.join("\n"))
+            sleep 1
+          ensure
+            main.mutex.synchronize{main.in_process -= 1}
+            main.close_if_needed(file)
+          end          
+        end
+      end
+    end 
+    
+    retry_previous_queue # Retry all work from previous iteration before we start processing this one.
+  end
+  
+  def debug(message)
+    if @debug
+      $stderr.print "#{Time.now} Cloudinary::Migrator #{message}\n"
+    end
+  end
+
+  def retry_previous_queue
+    last_id = 0
+    begin
+      prev_last_id, last_id = last_id, refill_queue(last_id)
+    end while last_id > prev_last_id
+    process_results    
+  end
+  
+  def process_all_pending
+    # Waiting for work to finish. While we are at it, process results.
+    while self.in_process > 0      
+      process_results
+      sleep 0.1
+    end
+    # Make sure we processed all the results
+    process_results
+  end
+  
+  def add_to_work_queue(row)
+    self.work << row
+    mutex.synchronize{self.in_process += 1}
+  end
+  
+  def wait_for_queue
+    # Waiting f
+    while self.work.length > @max_processing
+      process_results    
+      sleep 0.1
+    end    
+  end
+
+  def self.sample        
+    migrator = Cloudinary::Migrator.new(
+      :retrieve=>proc{|id| Post.find(id).data}, 
+      :complete=>proc{|id, result| a}
+      )
+    
+    Post.find_each(:conditions=>["id > ?", migrator.max_given_id], :select=>"id") do
+      |post|
+      migrator.process(:id=>post.id, :public_id=>"post_#{post.id}")
+    end
+    migrator.done
+  end 
+    
+  def self.test  
+    posts = {}
+    done = {}      
+    migrator = Cloudinary::Migrator.new(
+      :retrieve=>proc{|id| posts[id]}, 
+      :complete=>proc{|id, result| $stderr.print "done #{id} #{result}\n"; done[id] = result}
+      )
+    start = migrator.max_given_id + 1
+    (start..1000).each{|i| posts[i] = "hello#{i}"}
+    
+    posts.each do
+      |id, data|
+      migrator.process(:id=>id, :public_id=>"post_#{id}")
+    end
+    migrator.done
+    pp [done.length, start]
+  end        
+end

data/lib/cloudinary/uploader.rb

@@ -0,0 +1,114 @@
+# Copyright Cloudinary
+require 'rest_client'
+require 'json'
+
+class Cloudinary::Uploader
+  
+  def self.upload(file, options={})
+    call_api("upload", options) do    
+      params = {:timestamp=>Time.now.to_i,
+                :transformation => Cloudinary::Utils.generate_transformation_string(options),
+                :public_id=> options[:public_id],
+                :format=>options[:format],
+                :tags=>options[:tags] && Array(options[:tags]).join(",")}.reject{|k,v| v.blank?}    
+      if options[:eager]
+        params[:eager] = options[:eager].map do
+          |transformation|
+          transformation, format = Array(transformation) # format is optional
+          [Cloudinary::Utils.generate_transformation_string(transformation.clone), format].compact.join("/")
+        end.join("|")
+      end
+      if file.respond_to?(:read) || file =~ /^https?:/
+        params[:file] = file
+      else 
+        params[:file] = File.open(file, "rb")
+      end
+      [params, [:file]]
+    end              
+  end
+    
+  def self.generate_sprite(tag, options={})
+    version_store = options.delete(:version_store)
+    
+    result = call_api("sprite", options) do
+      {
+        :timestamp=>Time.now.to_i,
+        :tag=>tag,
+        :transformation => Cloudinary::Utils.generate_transformation_string(options)
+      }    
+    end
+    
+    if version_store == :file && result && result["version"]
+      if defined?(Rails) && defined?(Rails.root)
+        FileUtils.mkdir_p("#{Rails.root}/tmp/cloudinary")
+        File.open("#{Rails.root}/tmp/cloudinary/cloudinary_sprite_#{tag}.version", "w"){|file| file.print result["version"].to_s}                      
+      end  
+    end      
+    return result
+  end
+  
+  # options may include 'exclusive' (boolean) which causes clearing this tag from all other resources 
+  def self.add_tag(tag, public_ids = [], options = {})
+    exclusive = options.delete(:exclusive)
+    command = exclusive ? "set_exclusive" : "add"
+    return self.call_tags_api(tag, command, public_ids, options)    
+  end
+
+  def self.remove_tag(tag, public_ids = [], options = {})
+    return self.call_tags_api(tag, "remove", public_ids, options)    
+  end
+
+  def self.replace_tag(tag, public_ids = [], options = {})
+    return self.call_tags_api(tag, "replace", public_ids, options)    
+  end
+  
+  private
+  
+  def self.call_tags_api(tag, command, public_ids = [], options = {})
+    return call_api("tags", options) do
+      {
+        :timestamp=>Time.now.to_i,
+        :tag=>tag,
+        :public_ids => Array(public_ids),
+        :command => command
+      }    
+    end    
+  end
+     
+  def self.call_api(action, options)
+    options = options.clone
+    return_error = options.delete(:return_error)
+    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")
+
+    params, non_signable = yield
+    non_signable ||= []
+    
+    params[:signature] = Cloudinary::Utils.api_sign_request(params.reject{|k,v| non_signable.include?(k)}, api_secret)
+    params[:api_key] = api_key
+    cloudinary = options.delete(:upload_prefix) || Cloudinary.config.upload_prefix || "https://api.cloudinary.com"
+
+    resource_type = options.delete(:resource_type) || "image"
+    result = nil
+    cloud_name = Cloudinary.config.cloud_name || raise("Must supply cloud_name")
+    RestClient::Request.execute(:method => :post, :url => "#{cloudinary}/v1_1/#{cloud_name}/#{resource_type}/#{action}", :payload => params, :timeout=>60) do
+      |response, request, tmpresult|
+      raise "Server returned unexpected status code - #{response.code} - #{response.body}" if ![200,400,500].include?(response.code)
+      begin
+        result = Cloudinary::Utils.json_decode(response.body)
+      rescue => e
+        # Error is parsing json
+        raise "Error parsing server response (#{response.code}) - #{response.body}. Got - #{e}"
+      end
+      if result["error"]
+        if return_error
+          result["error"]["http_code"] = response.code
+        else
+          raise result["error"]["message"]
+        end
+      end        
+    end
+    
+    result    
+  end
+end

data/lib/cloudinary/utils.rb

@@ -0,0 +1,98 @@
+# Copyright Cloudinary
+require 'digest/sha1'
+
+class Cloudinary::Utils
+  SHARED_CDN = "d3jpl91pxevbkh.cloudfront.net"
+  
+  # Warning: options are being destructively updated!
+  def self.generate_transformation_string(options={})
+    width = options[:width]
+    height = options[:height]
+    size = options.delete(:size)
+    width, height = size.split("x") if size    
+    options.delete(:width) if width && width < 1 
+    options.delete(:height) if height && height < 1    
+     
+    crop = options.delete(:crop)
+    width=height=nil if crop.nil?
+    
+    gravity = options.delete(:gravity)
+    quality = options.delete(:quality)
+    named_transformation = Array(options.delete(:transformation)).join(".")
+    prefix = options.delete(:prefix)
+
+    params = {:w=>width, :h=>height, :t=>named_transformation, :c=>crop, :q=>quality, :g=>gravity, :p=>prefix}
+    transformation = params.reject{|k,v| v.blank?}.map{|k,v| [k.to_s, v]}.sort_by(&:first).map{|k,v| "#{k}_#{v}"}.join(",")
+    raw_transformation = options.delete(:raw_transformation)
+    transformation = [transformation, raw_transformation].reject(&:blank?).join(",")
+    transformation    
+  end
+  
+  def self.api_sign_request(params_to_sign, api_secret)
+    to_sign = params_to_sign.reject{|k,v| v.blank?}.map{|k,v| [k.to_s, v.is_a?(Array) ? v.join(",") : v]}.sort_by(&:first).map{|k,v| "#{k}=#{v}"}.join("&")
+    Digest::SHA1.hexdigest("#{to_sign}#{api_secret}")
+  end
+
+  # Warning: options are being destructively updated!
+  def self.cloudinary_url(source, options = {})
+    transformation = self.generate_transformation_string(options)
+
+    type = options.delete(:type) || :upload
+    resource_type = options.delete(:resource_type) || "image"
+    version = options.delete(:version)
+
+    format = options.delete(:format)
+    source = "#{source}.#{format}" if format
+    
+    # Configuration options
+    # newsodrome.cloudinary.com, images.newsodrome.com, cloudinary.com/res/newsodrome, a9fj209daf.cloudfront.net
+    cloud_name = options.delete(:cloud_name) || Cloudinary.config.cloud_name || raise("Must supply cloud_name in tag or in configuration")
+    
+    if cloud_name.start_with?("/")
+      prefix = "/res" + cloud_name
+    else
+      secure = options.delete(:secure) || Cloudinary.config.secure
+      private_cdn = options.delete(:private_cdn) || Cloudinary.config.private_cdn    
+      secure_distribution = options.delete(:secure_distribution) || Cloudinary.config.secure_distribution
+      if secure && secure_distribution.nil?
+        if private_cdn
+          raise "secure_distribution not defined"
+        else
+          secure_distribution = SHARED_CDN 
+        end
+      end
+      
+      if secure
+        prefix = "https://#{secure_distribution}"
+      else
+        prefix = "http://#{private_cdn ? "#{cloud_name}-" : ""}res.cloudinary.com"
+      end    
+      prefix += "/#{cloud_name}" if !private_cdn
+    end
+    
+    source = prefix + "/" + [resource_type, 
+     type, transformation, version ? "v#{version}" : nil,
+     source].reject(&:blank?).join("/").gsub("//", "/")
+  end
+  
+  def self.random_public_id
+    (defined?(ActiveSupport::SecureRandom) ? ActiveSupport::SecureRandom : SecureRandom).base64(16).downcase.gsub(/[^a-z0-9]/, "")    
+  end
+  
+  @@json_decode = false
+  def self.json_decode(str)
+    if !@@json_decode
+      @@json_decode = true
+      begin
+        require 'json'
+      rescue LoadError
+        begin
+          require 'active_support/json'
+        rescue LoadError
+          raise "Please add the json gem or active_support to your Gemfile"            
+        end
+      end
+    end
+    defined?(JSON) ? JSON.parse(str) : ActiveSupport::JSON.decode(str)
+  end
+end

data/lib/cloudinary/version.rb

@@ -0,0 +1,4 @@
+# Copyright Cloudinary
+module Cloudinary
+  VERSION = "1.0.0"
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: cloudinary
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Nadav Soferman
+- Itai Lahan
+- Tal Lev-Ami
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-02-22 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Client library for easily using the Cloudinary service
+email: 
+- nadav.soferman@cloudinary.com
+- itai.lahan@cloudinary.com
+- tal.levami@cloudinary.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- cloudinary.gemspec
+- lib/cloudinary.rb
+- lib/cloudinary/blob.rb
+- lib/cloudinary/carrier_wave.rb
+- lib/cloudinary/downloader.rb
+- lib/cloudinary/helper.rb
+- lib/cloudinary/helpers.rb
+- lib/cloudinary/migrator.rb
+- lib/cloudinary/uploader.rb
+- lib/cloudinary/utils.rb
+- lib/cloudinary/version.rb
+has_rdoc: true
+homepage: http://cloudinary.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: cloudinary
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Client library for easily using the Cloudinary service
+test_files: []
+