rmb 3.0.0

data/Gemfile

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+
+# TODO have this generated from gem spec or vice versa
+
+gem "mime-types"
+gem "json"
+gem "httparty", "0.6.1"
+gem "multipart-post"
+gem "activesupport", "2.3.9"
+
+group :development, :test do
+  gem "echoe"
+  gem "rake"
+  gem "rspec", "1.3.0"
+  gem "diff-lcs"
+  gem "fakeweb"
+end

data/History.rdoc

@@ -0,0 +1,32 @@
+=== 3.0 / 2010-09-21
+
+* Bump httparty requirement to 0.6.
+* Remove methods referencing deprecated 3.0 API calls
+* Add conversion API methods
+
+=== 1.7 / 2010-02-08
+
+* Added 0.5.2 as a requirement for httparty
+* Added debug mode in Dropio::Config
+
+=== 1.0.1 - 1.0.6=7 / 2009-10-08
+
+* Final button ups.
+* Addition of pingback urls and convert to parameters.
+* Pagination of comments and subscriptions
+
+=== 1.0.0 / 2009-10-02
+
+* Moved to API version 2.0
+
+=== 0.9.6 / 2009-10-01
+
+* Removed original file attribute from gem.
+
+=== 0.9.5 / 2009-09-09
+
+* Move gem to github.
+
+=== 0.9.0 / 2008-11-10
+
+* First gem release.

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Drop.io, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

data/Manifest

@@ -0,0 +1,25 @@
+Gemfile
+History.rdoc
+LICENSE.txt
+Manifest
+Rakefile
+Readme.rdoc
+Todo.rdoc
+dropio.gemspec
+lib/dropio.rb
+lib/dropio/api.rb
+lib/dropio/asset.rb
+lib/dropio/client.rb
+lib/dropio/drop.rb
+lib/dropio/job.rb
+lib/dropio/resource.rb
+lib/dropio/subscription.rb
+lib/dropio/version.rb
+spec/dropio/api_spec.rb
+spec/dropio/asset_spec.rb
+spec/dropio/client_spec.rb
+spec/dropio/drop_spec.rb
+spec/dropio/subscription_spec.rb
+spec/dropio_spec.rb
+spec/spec.opts
+spec/spec_helper.rb

data/Rakefile

@@ -0,0 +1,71 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup :development, :test
+
+$: << File.expand_path('./lib')
+require 'rmb/version'
+
+### Echoe
+begin
+  require 'echoe'
+
+  Echoe.new('rmb', Rmb::VERSION) do |echoe|
+    echoe.summary = "A Ruby client library for the Rich Media Backbone (RMB) API (http://rmb.io)"
+    echoe.author = ["Jake Good", "Eric Skiff", "Kunal Shah", "Seth Thomas Rasmussen", "Bryan Woods"]
+    echoe.email = ["jake@dropio.com", "eric@dropio.com", "kunal@dropio.com", "seth@dropio.com", "bryan@dropio.com"]
+    echoe.url = "http://github.com/dropio/rmb"
+    echoe.retain_gemspec = true
+    echoe.changelog = "History.rdoc"
+    
+    # TODO have this generated from Gemfile or vice versa
+    echoe.runtime_dependencies     = ["mime-types", "json", "httparty 0.6.1", "multipart-post 1.0.1", "activesupport 2.3.9"]
+    echoe.development_dependencies = ["rspec", "diff-lcs", "fakeweb"]
+    
+    echoe.ignore_pattern = "tmtags"
+    # Use this rdoc_pattern when building docs locally or publishing docs.
+    # echoe.rdoc_pattern = Regexp.union(echoe.rdoc_pattern, /\.rdoc$/)
+    echoe.rdoc_pattern   = /\.rdoc$/
+  end
+  
+  # Until we find a way to undefine rake tasks...
+  # %w{coverage clobber_coverage}.each { |name| Rake::Task[name].comment = "(don't use)" }
+  
+  # default depends on test, but we don't have a test task.  Define a trivial one.
+  task :test
+rescue LoadError
+  puts "(Note: Echoe not found.  Install echoe gem for package management tasks.)"
+end
+
+
+### RSpec
+require 'spec/rake/spectask'
+
+task :default => :spec
+Spec::Rake::SpecTask.new(:spec)
+
+namespace :spec do
+  Spec::Rake::SpecTask.new(:rcov) do |t|
+    t.rcov = true
+    t.rcov_opts = %w{ --exclude ^/ --exclude ^spec/ --sort coverage }
+  end
+  
+  namespace :rcov do
+    desc "Generate and view RCov report"
+    task :view => :rcov do
+      coverage_index = File.expand_path(File.join(File.dirname(__FILE__), 'coverage', 'index.html'))
+      sh "open file://#{coverage_index}"
+    end
+  end
+end
+
+
+### RDoc
+require 'rake/rdoctask'
+
+namespace :docs do
+  desc "Generate and view RDoc documentation"
+  task :view => :docs do
+    doc_index = File.expand_path(File.join(File.dirname(__FILE__), 'doc', 'index.html'))
+    sh "open file://#{doc_index}"
+  end
+end

data/Readme.rdoc

@@ -0,0 +1,23 @@
+(Note: This is very beta.  The code is mostly functional.  The docs are mostly not.  The tests are somewhere in between.  Have fun, be safe, and stay tuned.)
+
+= RMB API library for Ruby
+
+Documentation for this library is available here: http://backbonedocs.drop.io/Ruby-API-Client-Library
+
+Before using the Rmb library, the application must set an API key.  This key will be used for all requests to the server.  To get an API key, go to http://backbone.drop.io.  Then make sure you set the API key before you use the API:
+
+  Rmb::Config.api_key = "83a05513ddddb73e75c9d8146c115f7fd8e90de6"
+
+You can also get debug information through STDERR by doing:
+
+  Rmb::Config.debug = true
+
+
+== The Drop object
+
+There are two ways to get a +Drop+ object.  The first is to access an existing drop:
+
+       drop = Rmb::Drop.find("mystuff")
+  auth_drop = Rmb::Drop.find("mystuff", "b9b2c8f2b8e655679d2fb62b83f8efec4fb4c8af")
+
+<tt>Drop#find</tt> takes two arguments: the name of the drop to get, and a credential token.  This can be an admin token, a user token, an admin password, or a guest password.  The drop's capabilities will be limited by the token, and the token is optional.  If the drop is authenticated with the admin token, it will be able to do anything.  If the drop is not authenticated with a token, it will have the same capabilities as any user visiting the drop.  If the drop is not found or the token is not accepted, <tt>#find</tt> will return +nil+.

data/lib/rmb/api.rb

@@ -0,0 +1,272 @@
+require 'rbconfig'
+require 'mime/types'
+require 'httparty'
+require 'net/http/post/multipart'
+require 'json'
+require 'active_support/ordered_hash'
+
+class Rmb::Api
+  include HTTParty
+  format :json
+
+  RUBY_VERSION = %w{MAJOR MINOR TEENY}.map { |k| Config::CONFIG[k] }.join(".")
+  USER_AGENT_STRING = "RmbAPI-Ruby/#{Rmb::VERSION} (Ruby #{RUBY_VERSION} #{Config::CONFIG["host"]}; +http://github.com/dropio/rmb/tree/)"
+  headers 'Accept' => 'application/json', 'User-Agent' => USER_AGENT_STRING, "Content-Type" => 'application/json'
+  def initialize
+    self.class.debug_output $stderr if Rmb::Config.debug
+    self.class.base_uri Rmb::Config.api_url
+    self.class.default_options[:timeout] = Rmb::Config.timeout
+  end
+
+  def drop(drop_name)
+    rmb_get("/drops/#{drop_name}", {})
+  end
+
+  def all_drops(page = 1)
+    rmb_get("/accounts/drops", {:page => page})
+  end
+
+  def generate_drop_url(drop_name)
+    signed_url(drop_name)
+  end
+
+  def create_drop(params = {})
+    rmb_post("/drops",params)
+  end
+
+  def update_drop(drop_name, params = {})
+    rmb_put("/drops/#{drop_name}", params)
+  end
+
+  def change_drop_name(drop_name, new_name)
+    params = {:name => new_name}
+    rmb_put("/drops/#{drop_name}", params)
+  end
+
+  def empty_drop(drop_name)
+    rmb_put("/drops/#{drop_name}/empty", {})
+  end
+
+  def delete_drop(drop_name)
+    rmb_delete("/drops/#{drop_name}", {})
+  end
+
+  def promote_nick(drop_name, nick)
+    rmb_post("/drops/#{drop_name}", {:nick => nick})
+  end
+
+  def drop_upload_code(drop_name)
+    rmb_get("/drops/#{drop_name}/upload_code", {})
+  end
+
+  def create_link(drop_name, url, title = nil, description = nil)
+    rmb_post("/drops/#{drop_name}/assets", {:url => url, :title => title, :description => description})
+  end
+
+  def create_note(drop_name, contents, title = nil, description = nil)
+    params = {:contents => contents, :title => title, :description => description}
+    rmb_post("/drops/#{drop_name}/assets", params)
+  end
+
+  def add_file(drop_name, file_path, description = nil, conversion = nil, pingback_url = nil, output_locations = nil)
+    url  = URI.parse(Rmb::Config.upload_url)
+    locs = output_locations.is_a?(Array) ? output_locations.join(',') : output_locations
+    r    = nil
+
+    File.open(file_path) do |file|
+      mime_type = (MIME::Types.type_for(file_path)[0] || MIME::Types["application/octet-stream"][0])
+
+      params = {
+        :api_key => Rmb::Config.api_key.to_s,
+        :format => 'json',
+        :version           => Rmb::Config.version
+      }
+
+      # stuff passed in by a user. Done like this as if you pass a parameter without a value it can cause an issue (with the output_locations anyway)
+      # although this will be fixed in the API, we shouldn't be doing it anyway.
+      params[:drop_name] = drop_name if drop_name
+      params[:description] = description if description
+      params[:pingback_url] = pingback_url if pingback_url
+      params[:output_locations] = locs if locs
+      params[:conversion] = conversion if conversion
+      params[:signature_mode] = "STRICT"
+      #sign the params at this point
+      params = sign_if_needed(params)
+      params[:file]  = UploadIO.new(file, mime_type, file_path)
+
+      req  = Net::HTTP::Post::Multipart.new(url.path, params)
+      http = Net::HTTP.new(url.host, url.port)
+      http.set_debug_output $stderr if Rmb::Config.debug
+      r = http.start{|http| http.request(req)}
+    end
+
+    (r.nil? or r.body.nil? or r.body.empty?) ? r : HTTParty::Response.new(r,Crack::JSON.parse(r.body))
+  end
+
+  def add_file_from_url(drop_name, url, description = nil, convert_to = nil, pingback_url = nil)
+    rmb_post("/drops/#{drop_name}/assets", {:file_url => url, :description => description, :convert_to => convert_to, :pingback_url => pingback_url})
+  end
+
+  def assets(drop_name, page = 1, order = :oldest)
+    rmb_get("/drops/#{drop_name}/assets", {:page => page, :order => order.to_s, :show_pagination_details => true})
+  end
+
+  def asset(drop_name, asset_name)
+    rmb_get("/drops/#{drop_name}/assets/#{asset_name}", {})
+  end
+  
+  def generate_asset_url(drop_name, asset_name)
+    signed_url(drop_name, asset_name)
+  end
+
+  def generate_original_file_url(drop_name, asset_id, time_to_live = 600)
+    #TODO - signed download URLs
+    #this is now available via the API response itself
+    download_url = Rmb::Config.api_url + "/drops/#{drop_name}/assets/#{asset_id}/download/original?"
+    params = {:version => Rmb::Config.version, :api_key=>Rmb::Config.api_key.to_s, :format=>'json'}
+    params = sign_if_needed(params)
+    paramstring = ''
+    params.each do |k, v|
+      paramstring << "#{k}=#{v}&"
+    end
+    paramstring.chop!
+    download_url += paramstring
+  end
+
+  def update_asset(drop_name, asset_name, params = {})
+    rmb_put("/drops/#{drop_name}/assets/#{asset_name}", params)
+  end
+  
+  def change_asset_name(drop_name, asset_name, new_name)
+    params = {:name => new_name}
+    rmb_put("/drops/#{drop_name}/assets/#{asset_name}", params)
+  end
+
+  def delete_asset(drop_name, asset_id)
+    rmb_delete("/drops/#{drop_name}/assets/#{asset_id}", {})
+  end
+
+  def delete_role(drop_name, asset_id, role, location=nil)
+    rmb_delete("/drops/#{drop_name}/assets/#{asset_id}", {:role => role, :output_location => location})
+  end
+
+  def send_asset_to_drop(drop_name, asset_name, target_drop)
+    rmb_post("/drops/#{drop_name}/assets/#{asset_name}/send_to", {:medium => "drop", :drop_name => target_drop})
+  end
+  
+  def copy_asset(drop_name, asset_name, target_drop)
+    params = {:drop_name => target_drop}
+    rmb_post("/drops/#{drop_name}/assets/#{asset_name}/copy", params)
+  end
+  
+  def move_asset(drop_name, asset_name, target_drop)
+    params = {:drop_name => target_drop}
+    rmb_post("/drops/#{drop_name}/assets/#{asset_name}/move", params)
+  end
+
+  def create_pingback_subscription(drop_name, url, events = {})
+    rmb_post("/drops/#{drop_name}/subscriptions", :body => {:type => "pingback", :url => url}.merge(events))
+  end
+
+  def subscriptions(drop_name, page)
+    rmb_get("/drops/#{drop_name}/subscriptions", :query => {:page => page, :show_pagination_details => true})
+  end
+
+  def delete_subscription(drop_name, subscription_id)
+    rmb_delete("/drops/#{drop_name}/subscriptions/#{subscription_id}", {})
+  end
+
+  def get_signature(params={})
+    #returns a signature for the passed params, without any modifcation to the params
+    params = sign_request(params)
+    params[:signature]
+  end
+
+  def job(id, drop_name, asset_name_or_id)
+    rmb_get("/drops/#{drop_name}/assets/#{asset_name_or_id}/jobs/#{id}", {})
+  end
+
+  def create_job(job = {})
+    rmb_post("/jobs",job)
+  end
+  alias_method :convert, :create_job
+
+  private
+
+  def sign_request(params={}, request="POST")
+    #returns all params, including signature and any required params for signing (currently only timestamp)
+    params_for_sig = params.clone
+    params_for_sig[:api_key] = Rmb::Config.api_key.to_s
+    params_for_sig[:version] = Rmb::Config.version.to_s
+
+    if params[:signature_mode] != "OPEN"
+      #RPC always includes format here, so in NORMAL and STRICT mode we need to include it in our sig if not specified
+      params_for_sig[:format] ||= 'json'
+      params[:format] ||= 'json'
+    end
+    
+    #Sort the clean params and put them into an ordered hash for to_json 
+    orderedparams = sort_hash_recursively(params_for_sig)
+    #compute the expected signature
+    puts "\r\nSigning this string: " + orderedparams.to_json + "\r\n" if Rmb::Config.debug
+    params[:signature] = Digest::SHA1.hexdigest(orderedparams.to_json + Rmb::Config.api_secret)
+    params
+  end
+  
+  def sign_if_needed(params = {}, method="POST")
+    if Rmb::Config.api_secret
+      params = add_required_signing_params(params)
+      params = sign_request(params, method)
+      params
+    else
+      params
+    end
+  end
+
+  def add_required_signing_params(params = {})
+    #10 minute window
+    params[:timestamp] = (Time.now.to_i + 600).to_s
+    params
+  end
+
+  def add_default_params(params = {})
+    default_params = {:api_key => Rmb::Config.api_key.to_s, :version => Rmb::Config.version.to_s, :format => "json" }
+    params = params.merge(default_params)
+    params
+  end
+
+  def rmb_get(action, params={})
+    self.class.get(action, :query => add_default_params(sign_if_needed(params, "GET")))
+  end
+
+  def rmb_post(action, params={})
+    self.class.post(action, :body => add_default_params(sign_if_needed(params, "POST")).to_json)
+  end
+
+  def rmb_put(action, params={})
+    self.class.put(action, :body => add_default_params(sign_if_needed(params, "PUT")).to_json)
+  end
+
+  def rmb_delete(action,params={})
+    self.class.delete(action, :body => add_default_params(sign_if_needed(params, "DELETE")).to_json)
+  end
+  
+  def sort_hash_recursively(oldhash = {}, depth = 0)
+    return false if depth > 4
+    sortedhash = ActiveSupport::OrderedHash.new
+    oldhash.keys.sort_by {|s| s.to_s}.each {|key| 
+        if oldhash[key].is_a? Hash
+            sortedhash[key] = sort_hash_recursively(oldhash[key], depth + 1)
+        elsif oldhash[key].is_a? Array
+            oldhash[key].map! do |element|
+                element = sort_hash_recursively(element, depth + 1)
+            end
+            sortedhash[key] = oldhash[key]
+        else
+            sortedhash[key] = oldhash[key].to_s
+        end
+    }
+    return sortedhash
+  end
+  
+end

data/lib/rmb/asset.rb

@@ -0,0 +1,65 @@
+class Rmb::Asset < Rmb::Resource
+  
+  attr_accessor :id, :drop, :name, :type, :title, :description, :filesize, :created_at, :status, 
+                :pages, :duration, :artist, :track_title, :height, :width, :contents, :url,
+                :roles, :locations
+     
+  # Finds a particular Asset by drop and asset name.
+  def self.find(drop, id)
+    Rmb::Resource.client.asset(drop, id)
+  end
+  
+  # Changes the name of an asset.
+  def change_name(new_name)
+    Rmb::Resource.client.change_asset_name(self,new_name)
+  end
+  
+  # Saves the Asset back to the RMB
+  def save
+    Rmb::Resource.client.update_asset(self)
+  end
+  
+  # Destroys the Asset on the RMB  Don't try to use an Asset after destroying it.
+  def destroy!
+    Rmb::Resource.client.delete_asset(self)
+    return nil
+  end
+  
+  # Destroys the given role on an Asset
+  def destroy_role!(role)
+    Rmb::Resource.client.delete_role(self, role)
+    return nil
+  end
+  
+  # Destroys the given role at the specified location on an Asset
+  def destroy_location!(role, location)
+    Rmb::Resource.client.delete_role(self, role, location)
+    return nil
+  end
+  
+  # Copies the Asset to the given drop.
+  def copy_to(target_drop)
+    Rmb::Resource.client.copy_asset(self, target_drop)
+  end
+  
+  # Moves the Asset to the given drop.
+  def move_to(target_drop)
+    Rmb::Resource.client.move_asset(self, target_drop)
+  end
+  
+  # Sends the Asset to a Drop by +drop_name+
+  def send_to_drop(drop)
+    Rmb::Resource.client.copy_asset(self, drop)
+  end
+  
+  # Generates an authenticated URL that will bypass any login action.
+  def generate_url
+    Rmb::Resource.client.generate_asset_url(self)
+  end
+  
+  # Generates a url if there's access to the original file.
+  def original_file_url(time_to_live = 600)
+    Rmb::Resource.client.generate_original_file_url(self)
+  end
+  
+end