rmb 3.0.0

data/lib/rmb/client.rb

@@ -0,0 +1,205 @@
+class Rmb::Client
+  attr_accessor :service
+
+  def initialize
+    self.service = Rmb::Api.new
+  end
+  
+  def drop(drop_name)
+    handle(:drop, self.service.drop(drop_name))
+  end
+
+  def all_drops(page = 1)
+    handle(:drops, self.service.all_drops(page))
+  end
+
+  def generate_drop_url(drop)
+    self.service.generate_drop_url(drop.name)
+  end
+
+  def create_drop(params = {})
+    handle(:drop, self.service.create_drop(params))
+  end
+
+  def change_drop_name(drop, new_name)
+    handle(:drop, self.service.change_drop_name(drop.name,new_name))
+    drop.name = new_name
+    drop
+  end
+
+  def update_drop(drop)
+    params = { :description => drop.description, :admin_email => drop.admin_email,
+               :email_key => drop.email_key, :chat_password => drop.chat_password,
+               :expiration_length => drop.expiration_length, :password => drop.password,
+               :admin_password => drop.admin_password }
+    handle(:drop, self.service.update_drop(drop.name,params))
+  end
+
+  def empty_drop(drop)
+    r = handle(:response, self.service.empty_drop(drop.name))
+    r["result"]
+  end
+
+  def delete_drop(drop)
+    r = handle(:response, self.service.delete_drop(drop.name))
+    r["result"]
+  end
+
+  def promote_nick(drop,nick)
+    r = handle(:response, self.service.promote_nick(drop.name,nick))
+    r["result"]
+  end
+
+  def drop_upload_code(drop)
+    r = handle(:response, self.service.drop_upload_code(drop.name))
+    r["upload_code"]
+  end
+
+  def create_link(drop, url, title = nil, description = nil)
+    a = handle(:asset, self.service.create_link(drop.name, url, title, description))
+    a.drop = drop
+    a
+  end
+
+  def create_note(drop, contents, title = nil, description = nil)
+    a = handle(:asset, self.service.create_note(drop.name, contents, title, description))
+    a.drop = drop
+    a
+  end
+
+  def add_file(drop, file_path, description = nil, convert_to = nil, pingback_url = nil, output_locations = nil)
+    a = handle(:asset, self.service.add_file(drop.name, file_path, description, convert_to, pingback_url, output_locations))
+    a.drop = drop
+    a
+  end
+
+  def add_file_from_url(drop, url, description = nil, convert_to = nil, pingback_url = nil)
+    a = handle(:asset, self.service.add_file_from_url(drop.name, url, description, convert_to, pingback_url))
+    a.drop = drop
+    a
+  end
+
+  def assets(drop, page = 1, order = :oldest)
+    assets = handle(:assets, self.service.assets(drop.name,page,order))
+    assets.each{|a| a.drop = drop}
+    assets
+  end
+
+  def asset(drop, asset_name)
+    a = handle(:asset, self.service.asset(drop.name,asset_name))
+    a.drop = drop
+    a
+  end
+
+  def generate_asset_url(asset)
+    self.service.generate_asset_url(asset.drop.name, asset.name)
+  end
+
+  def generate_original_file_url(asset)
+    self.service.generate_original_file_url(asset.drop.name, asset.name)
+  end
+
+  def update_asset(asset)
+    params = { :title => asset.title, :description => asset.description, :url => asset.url, :contents => asset.contents }
+    a = handle(:asset, self.service.update_asset(asset.drop.name,asset.name,params))
+    a.drop = asset.drop
+    a
+  end
+
+  def change_asset_name(asset, new_name)
+    handle(:asset, self.service.change_asset_name(asset.drop.name,asset.name,new_name))
+    asset.name = new_name
+    asset
+  end
+
+  def delete_asset(asset)
+    r = handle(:response, self.service.delete_asset(asset.drop.name, asset.id))
+    r["result"]
+  end
+
+  def delete_role(asset, role, location=nil)
+    r = handle(:response, self.service.delete_role(asset.drop.name, asset.id, role, location))
+    r["result"]
+  end
+
+  def send_asset_to_drop(asset, target_drop)
+    r = handle(:response, self.service.send_asset_to_drop(asset.drop.name, asset.name, target_drop.name))
+    r["result"]
+  end
+
+  def copy_asset(asset,target_drop)
+    r = handle(:response, self.service.copy_asset(asset.drop.name,asset.name,target_drop.name))
+    r["result"]
+  end
+
+  def move_asset(asset,target_drop)
+    r = handle(:response, self.service.move_asset(asset.drop.name,asset.name,target_drop.name))
+    r["result"]
+  end
+
+  def create_pingback_subscription(drop, url, events)
+    s = handle(:subscription, self.service.create_pingback_subscription(drop.name, url, events))
+    s.drop = drop
+    s
+  end
+
+  def subscriptions(drop, page = 1)
+    subscriptions = handle(:subscriptions, self.service.subscriptions(drop.name, page))
+    subscriptions.each{|s| s.drop = drop}
+    subscriptions
+  end
+
+  def delete_subscription(subscription)
+    r = handle(:response, self.service.delete_subscription(subscription.drop.name,subscription.id))
+    r["result"]
+  end
+  
+  def job(id, drop_name, asset_name_or_id)
+    handle(:job, self.service.job(id, drop_name, asset_name_or_id))
+  end
+
+  def create_job(job = {})
+    handle(:job, self.service.create_job(job))
+  end
+
+  private
+
+  def handle(type, response)
+    if response.code != 200
+      parse_response(response)
+    end
+
+    case type
+    when :drop then return Rmb::Drop.new(response)
+    when :drops then return response['drops'].collect{|d| Rmb::Drop.new(d)}
+    when :asset then return Rmb::Asset.new(response)
+    when :assets then return response['assets'].collect{|a| Rmb::Asset.new(a)}
+    when :subscription then return Rmb::Subscription.new(response)
+    when :subscriptions then return response['subscriptions'].collect{|s| Rmb::Subscription.new(s)}
+    when :job then return Rmb::Job.new(response)
+    when :response then return parse_response(response)
+    end
+  end
+
+  def parse_response(response)
+    case response.code
+    when 200 then return response
+    when 400 then raise Rmb::RequestError, parse_error_message(response)
+    when 403 then raise Rmb::AuthorizationError, parse_error_message(response)
+    when 404 then raise Rmb::MissingResourceError, parse_error_message(response)
+    when 500 then raise Rmb::ServerError, "There was a problem connecting to rmb.io."
+    else
+      raise "Received an unexpected HTTP response: #{response.code} #{response.body}"
+    end
+  end
+
+  # Extracts the error message from the response for the exception.
+  def parse_error_message(error_hash)
+    if (error_hash && error_hash.is_a?(Hash) && error_hash["response"] && error_hash["response"]["message"])
+      return error_hash["response"]["message"]
+    else
+      return "There was a problem connecting to rmb.io."
+    end
+  end
+
+end

data/lib/rmb/drop.rb

@@ -0,0 +1,89 @@
+class Rmb::Drop < Rmb::Resource
+  
+  attr_accessor :name, :email, :description, :expires_at, :expiration_length, 
+                :max_bytes, :current_bytes, :asset_count, :chat_password, :password, 
+                :admin_password, :admin_email, :email_key
+  
+  # Gets a list of assets associated with the Drop. Paginated at 
+  def assets(page = 1, order = :oldest)
+    Rmb::Resource.client.assets(self, page, order)
+  end
+  
+  # Finds a drop with +name+
+  def self.find(name)
+    Rmb::Resource.client.drop(name)
+  end
+  
+  # Finds all the drops associated with an API account by page
+  def self.find_all(page = 1)
+    Rmb::Resource.client.all_drops(page)
+  end
+  
+  # Creates a drop with an +attributes+ hash.
+  # Valid attributes: name (string), expiration_length (string), password (string), and admin_password (string)
+  # Descriptions can be found here: http://backbonedocs.drop.io/Ruby-API-Client-Library:Drop
+  def self.create(attributes = {})
+    Rmb::Resource.client.create_drop(attributes)
+  end
+  
+  # Changes the name of a drop.
+  def change_name(new_name)
+    Rmb::Resource.client.change_drop_name(self,new_name)
+  end
+  
+  # Empties the drop, including it's assets.
+  def empty
+    Rmb::Resource.client.empty_drop(self)
+  end
+  
+  # Promotes a nickname in the drop chat to admin.
+  def promote(nick)
+    Rmb::Resource.client.promote_nick(self,nick)
+  end
+  
+  # Saves the Drop.
+  def save
+    Rmb::Resource.client.update_drop(self)
+  end
+  
+  # Deletes the Drop from the system including all associated assets.
+  def destroy!
+    Rmb::Resource.client.delete_drop(self)
+  end
+  
+  # Adds a file to the Drop from a given +url+
+  def add_file_from_url(url, description = nil, convert_to = nil, pingback_url = nil)
+    Rmb::Resource.client.add_file_from_url(self,url,description, convert_to, pingback_url)
+  end
+  
+  # Adds a file to the Drop given the +file_path+.
+  def add_file(file_path, description = nil, convert_to = nil, pingback_url = nil, output_locations = nil)
+    Rmb::Resource.client.add_file(self, file_path, description, convert_to, pingback_url, output_locations)
+  end
+  
+  # Creates a note with a +title+ and +contents+
+  def create_note(contents, title = nil, description = nil)
+    Rmb::Resource.client.create_note(self, contents, title, description)
+  end
+  
+  # Creates a link with a +url+, +title+, and +description+.
+  def create_link(url, title = nil, description = nil)
+    Rmb::Resource.client.create_link(self, url, title, description)
+  end
+  
+  # Creates a subscription to receive POSTs from rmb.io.
+  def create_pingback_subscription(url, events = {})
+    Rmb::Resource.client.create_pingback_subscription(self,url,events)
+  end
+  
+  # Gets a list of Subscription objects.
+  def subscriptions(page = 1)
+    Rmb::Resource.client.subscriptions(self, page)
+  end
+  
+  # Generates an authenticated URL that will bypass any login action.
+  def generate_url
+    Rmb::Resource.client.generate_drop_url(self)
+  end
+  
+end

data/lib/rmb/job.rb

@@ -0,0 +1,22 @@
+class Rmb::Job < Rmb::Resource
+  
+  attr_accessor :id, :job_type, :using, :inputs, :outputs, :pingback_url, :state
+  
+  # Finds a job for a drop and asset
+  def self.find(id,drop_name,asset_name_or_id)
+    Rmb::Resource.client.job(id, drop_name, asset_name_or_id)
+  end
+
+  # Creates a job
+  def self.create(job_type,using,inputs,outputs,pingback_url=nil)
+    Rmb::Resource.client.create_job({
+      :job_type => job_type,
+      :using => using,
+      :inputs => inputs,
+      :outputs => outputs,
+      :pingback_url => pingback_url
+    })
+  end
+ 
+  
+end

data/lib/rmb/resource.rb

@@ -0,0 +1,13 @@
+class Rmb::Resource
+  
+  def initialize(params = {})
+    params.each do |key,val|
+      self.send("#{key}=", val) if self.respond_to?("#{key}=")
+    end
+  end
+
+  def self.client
+    @@client ||= Rmb::Client.new
+  end
+  
+end

data/lib/rmb/subscription.rb

@@ -0,0 +1,10 @@
+class Rmb::Subscription < Rmb::Resource
+  attr_accessor :id, :username, :message, :type, :drop
+  
+  # Destroys the given subscription
+  def destroy!
+    Rmb::Resource.client.delete_subscription(self)
+    nil
+  end
+  
+end

data/lib/rmb/version.rb

@@ -0,0 +1,3 @@
+module Rmb
+  VERSION = '3.0.0'
+end

data/lib/rmb.rb

@@ -0,0 +1,33 @@
+require 'rmb/version'
+
+module Rmb
+  class Error < StandardError; end
+  
+  class MissingResourceError < Error; end
+  class AuthorizationError   < Error; end
+  class RequestError         < Error; end
+  class ServerError          < Error; end
+  
+  class Config
+    class << self
+      attr_accessor :api_key, :api_secret, :base_url, :api_url, :upload_url, :version, :debug, :timeout
+    end
+  end
+  
+end
+
+Rmb::Config.base_url   = "http://down.rmb.io"
+Rmb::Config.api_url    = "http://api.rmb.io"
+Rmb::Config.upload_url = "http://up.rmb.io/upload"
+Rmb::Config.version    = "3.0"
+Rmb::Config.debug      = false
+Rmb::Config.timeout    = 60 # Default in Ruby
+
+require 'rmb/api'
+require 'rmb/client'
+require 'rmb/resource'
+require 'rmb/drop'
+require 'rmb/asset'
+require 'rmb/subscription'
+require 'rmb/job'
+

data/rmb.gemspec

@@ -0,0 +1,53 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rmb}
+  s.version = "3.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jake Good, Eric Skiff, Kunal Shah, Seth Thomas Rasmussen, Matthew Rathbone", "Bryan Woods"]
+  s.date = %q{2010-09-21}
+  s.description = %q{A Ruby client library for the Rich Media Backbone (RMB) API (http://rmb.io). Please send all feedback to backbone@dropio.com}
+  s.email = ["jake@dropio.com", "eric@dropio.com", "kunal@dropio.com", "seth@dropio.com", "matthew@dropio.com", "bryan@dropio.com"]
+  s.extra_rdoc_files = ["History.rdoc", "Readme.rdoc"]
+  s.files = ["Gemfile", "History.rdoc", "LICENSE.txt", "Manifest", "Rakefile", "Readme.rdoc", "rmb.gemspec", "lib/rmb.rb", "lib/rmb/api.rb", "lib/rmb/asset.rb", "lib/rmb/client.rb", "lib/rmb/drop.rb", "lib/rmb/job.rb", "lib/rmb/resource.rb", "lib/rmb/subscription.rb", "lib/rmb/version.rb", "spec/rmb/api_spec.rb", "spec/rmb/asset_spec.rb", "spec/rmb/client_spec.rb", "spec/rmb/drop_spec.rb", "spec/rmb/subscription_spec.rb", "spec/rmb_spec.rb", "spec/spec.opts", "spec/spec_helper.rb"]
+  s.homepage = %q{http://github.com/dropio/rmb}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Dropio", "--main", "Readme.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{rmb}
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{A Ruby client library for the Drop.io Rich Media Backbone (RMB) API (http://rmb.io)}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<mime-types>, [">= 0"])
+      s.add_runtime_dependency(%q<json>, [">= 0"])
+      s.add_runtime_dependency(%q<httparty>, ["= 0.6.1"])
+      s.add_runtime_dependency(%q<multipart-post>, ["= 1.0.1"])
+      s.add_runtime_dependency(%q<activesupport>, ["= 2.3.9"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<diff-lcs>, [">= 0"])
+      s.add_development_dependency(%q<fakeweb>, [">= 0"])
+    else
+      s.add_dependency(%q<mime-types>, [">= 0"])
+      s.add_dependency(%q<json>, [">= 0"])
+      s.add_dependency(%q<httparty>, ["= 0.6.1"])
+      s.add_dependency(%q<multipart-post>, ["= 1.0.1"])
+      s.add_runtime_dependency(%q<activesupport>, ["= 2.3.9"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<diff-lcs>, [">= 0"])
+      s.add_dependency(%q<fakeweb>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<mime-types>, [">= 0"])
+    s.add_dependency(%q<json>, [">= 0"])
+    s.add_dependency(%q<httparty>, ["= 0.6.1"])
+    s.add_dependency(%q<multipart-post>, ["= 1.0.1"])
+    s.add_runtime_dependency(%q<activesupport>, ["= 2.3.9"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<diff-lcs>, [">= 0"])
+    s.add_dependency(%q<fakeweb>, [">= 0"])
+  end
+end

data/spec/rmb/asset_spec.rb

@@ -0,0 +1,93 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Rmb::Asset do
+  before(:each) do
+    @drop = Rmb::Drop.new
+    @drop.name = "test_drop"
+    @asset = Rmb::Asset.new
+    @asset.name = "test_asset"
+    @asset.drop = @drop
+
+    @client = Rmb::Client.new
+    @api = stub(Rmb::Api)
+    @client.service = @api
+
+    Rmb::Resource.stub!(:client).and_return(@client)
+    Rmb::Resource.client.should == @client
+    Rmb::Resource.client.service.should == @api
+  end
+
+  it "should have the attributes of an Asset" do
+    @asset.should respond_to(:drop, :name, :type, :title, :description, :filesize, :created_at,
+                             :status, :pages, :duration, :artist,
+                             :track_title, :height, :width, :contents, :url)
+  end
+
+  it "should save itself" do
+    @client.should_receive(:handle).with(:asset,{}).and_return(@asset)
+    expected_hash = {:url=> "http://rmb.io", :contents=>nil, :description=>nil, :title=>nil}
+    @asset.url = expected_hash[:url]
+    @api.stub!(:update_asset).and_return({})
+    @asset.save
+  end
+
+  it "should destroy itself" do
+    @client.should_receive(:handle).with(:response,{}).and_return({"result" => "Success"})
+    @api.stub!(:delete_asset).with(@drop.name, @asset.id).and_return({})
+    @asset.destroy!
+  end
+
+  it "should destroy roles" do
+    @client.should_receive(:handle).with(:response,{}).and_return({"result" => "Success"})
+    @api.stub!(:delete_role).with(@drop.name, @asset.id, "thumbnail", nil).and_return({})
+    @asset.destroy_role!("thumbnail")
+  end
+
+  it "should destroy roles at locations" do
+    @client.should_receive(:handle).with(:response,{}).and_return({"result" => "Success"})
+    @api.stub!(:delete_role).with(@drop.name, @asset.id, "thumbnail", "RmbS3").and_return({})
+    @asset.destroy_location!("thumbnail","RmbS3")
+  end
+
+  it "should send itself to another drop." do
+    @target_drop = Drop.new
+    @target_drop.name = "target_drop"
+    @client.should_receive(:handle).with(:response,{}).and_return({"result" => "Success"})
+    @api.stub!(:copy_asset).and_return({})
+    @asset.send_to_drop(@target_drop)
+  end
+
+  it "should copy itself to another drop." do
+    @target_drop = Drop.new
+    @target_drop.name = "target_drop"
+    @client.should_receive(:handle).with(:response,{}).and_return({"result" => "Success"})
+    @api.stub!(:copy_asset).and_return({})
+    @asset.copy_to(@target_drop)
+  end
+
+  it "should move itself to another drop." do
+    @target_drop = Drop.new
+    @target_drop.name = "target_drop"
+    @client.should_receive(:handle).with(:response,{}).and_return({"result" => "Success"})
+    @api.stub!(:move_asset).and_return({})
+    @asset.move_to(@target_drop)
+  end
+
+  it "should find itself" do
+    @client.should_receive(:handle).with(:asset,{}).and_return(@asset)
+    @api.should_receive(:asset).with(@drop.name, @asset.id).and_return({})
+    Asset.find(@drop, @asset.id).should == @asset
+  end
+
+  it "should generate a signed url" do
+    @api.should_receive(:generate_asset_url)
+    @asset.generate_url
+  end
+
+  it "should have an original file url" do
+    @api.should_receive(:generate_original_file_url)
+    @asset.original_file_url
+  end
+
+  
+end