dropio 3.0.0.pre3 → 3.0.0.pre4

data/Gemfile

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

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Drop.io, Inc.
+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

data/Manifest

@@ -1,23 +1,24 @@
+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/comment.rb
 lib/dropio/drop.rb
 lib/dropio/resource.rb
 lib/dropio/subscription.rb
-lib/dropio.rb
-LICENSE.txt
-Manifest
-Rakefile
-Readme.rdoc
+lib/dropio/version.rb
 spec/dropio/api_spec.rb
 spec/dropio/asset_spec.rb
 spec/dropio/client_spec.rb
-spec/dropio/comment_spec.rb
 spec/dropio/drop_spec.rb
 spec/dropio/subscription_spec.rb
 spec/dropio_spec.rb
 spec/spec.opts
 spec/spec_helper.rb
-Todo.rdoc

data/Rakefile

@@ -1,26 +1,34 @@
-$: << 'lib'
-require 'dropio'
+require 'rubygems'
+require 'bundler'
+Bundler.setup :development, :test
+
+$: << File.expand_path('./lib')
+require 'dropio/version'
 
 ### Echoe
 begin
   require 'echoe'
 
   Echoe.new('dropio', Dropio::VERSION) do |echoe|
-    echoe.summary = "A Ruby client library for the Drop.io API (http://api.drop.io)"
-    echoe.author = ["Jake Good"]
-    echoe.email = ["jake@dropio.com"]
+    echoe.summary = "A Ruby client library for the Drop.io Rich Media Backbone (RMB) API (http://backbone.drop.io)"
+    echoe.author = ["Jake Good", "Eric Skiff", "Kunal Shah", "Seth Thomas Rasmussen"]
+    echoe.email = ["jake@dropio.com", "eric@dropio.com", "kunal@dropio.com", "seth@dropio.com"]
     echoe.url = "http://github.com/dropio/dropio"
+    echoe.retain_gemspec = true
     echoe.changelog = "History.rdoc"
-    echoe.ignore_pattern = "tmtags"
-    echoe.runtime_dependencies = ["mime-types", "json"]
     
+    # TODO have this generated from Gemfile or vice versa
+    echoe.runtime_dependencies     = ["mime-types", "json", "httparty 0.6.1", "multipart-post"]
+    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$/
+    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)" }
+  # %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
@@ -61,4 +69,3 @@ namespace :docs do
     sh "open file://#{doc_index}"
   end
 end
-

data/Readme.rdoc

@@ -2,7 +2,7 @@
 
 = drop.io API library for Ruby
 
-Before using the Dropio 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://api.drop.io.  Then make sure you set the API key before you use the API:
+Before using the Dropio 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:
 
   Dropio::Config.api_key = "83a05513ddddb73e75c9d8146c115f7fd8e90de6"
 

data/dropio.gemspec

@@ -2,42 +2,50 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dropio}
-  s.version = "3.0.0.pre3"
+  s.version = "3.0.0.pre4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Jake Good"]
-  s.date = %q{2009-10-01}
-  s.description = %q{A Ruby client library for the Drop.io API (http://api.drop.io). Please email jake@dropio.com with any questions.}
-  s.email = ["jake@dropio.com"]
+  s.authors = ["Jake Good, Eric Skiff, Kunal Shah, Seth Thomas Rasmussen"]
+  s.date = %q{2010-08-31}
+  s.description = %q{A Ruby client library for the Drop.io Rich Media Backbone (RMB) API (http://backbone.drop.io). Please email support@dropio.com for any issues.}
+  s.email = ["jake@dropio.com", "eric@dropio.com", "kunal@dropio.com", "seth@dropio.com"]
   s.extra_rdoc_files = ["History.rdoc", "Readme.rdoc", "Todo.rdoc"]
-  s.files = ["History.rdoc", "lib/dropio/api.rb", "lib/dropio/asset.rb", "lib/dropio/client.rb", "lib/dropio/comment.rb", "lib/dropio/drop.rb", "lib/dropio/resource.rb", "lib/dropio/subscription.rb","lib/dropio.rb", "LICENSE.txt", "Manifest", "Rakefile", "Readme.rdoc", "spec/dropio/api_spec.rb", "spec/dropio/asset_spec.rb", "spec/dropio/client_spec.rb", "spec/dropio/comment_spec.rb", "spec/dropio/drop_spec.rb","spec/dropio/subscription_spec.rb", "spec/dropio_spec.rb", "spec/spec.opts", "spec/spec_helper.rb", "Todo.rdoc", "dropio.gemspec"]
-  s.has_rdoc = true
+  s.files = ["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/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"]
   s.homepage = %q{http://github.com/dropio/dropio}
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Dropio", "--main", "Readme.rdoc"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{dropio}
-  s.rubygems_version = %q{1.3.0}
-  s.summary = %q{A Ruby client library for the Drop.io API (http://api.drop.io)}
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{A Ruby client library for the Drop.io Rich Media Backbone (RMB) API (http://backbone.drop.io)}
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 2
+    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<httparty>, [">= 0.6.1"])
-      s.add_runtime_dependency(%q<multipart-post>,[">= 0"])
-      s.add_development_dependency(%q<echoe>, [">= 0"])
+      s.add_runtime_dependency(%q<json>, [">= 0"])
+      s.add_runtime_dependency(%q<httparty>, ["= 0.6.1"])
+      s.add_runtime_dependency(%q<multipart-post>, [">= 0"])
+      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<httparty>, [">= 0.6.1"])
+      s.add_dependency(%q<json>, [">= 0"])
+      s.add_dependency(%q<httparty>, ["= 0.6.1"])
       s.add_dependency(%q<multipart-post>, [">= 0"])
-      s.add_dependency(%q<echoe>, [">= 0"])
+      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<httparty>, [">= 0.6.1"])
+    s.add_dependency(%q<json>, [">= 0"])
+    s.add_dependency(%q<httparty>, ["= 0.6.1"])
     s.add_dependency(%q<multipart-post>, [">= 0"])
-    s.add_dependency(%q<echoe>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<diff-lcs>, [">= 0"])
+    s.add_dependency(%q<fakeweb>, [">= 0"])
   end
 end

data/lib/dropio/api.rb

@@ -1,4 +1,7 @@
 require 'rbconfig'
+require 'mime/types'
+require 'httparty'
+require 'net/http/post/multipart'
 
 class Dropio::Api
   include HTTParty
@@ -31,26 +34,25 @@ class Dropio::Api
     self.class.post("/drops",:body => sign_if_needed(params))
   end
 
-  def update_drop(drop_name, admin_token, params = {})
-    params[:token] = admin_token
+  def update_drop(drop_name, params = {})
     self.class.put("/drops/#{drop_name}", :body => sign_if_needed(params))
   end
   
-  def change_drop_name(drop_name, admin_token, new_name)
-    params = {:token => admin_token, :name => new_name}
+  def change_drop_name(drop_name, new_name)
+    params = {:name => new_name}
     self.class.put("/drops/#{drop_name}", :body => sign_if_needed(params))
   end
   
-  def empty_drop(drop_name, admin_token)
-    self.class.put("/drops/#{drop_name}/empty", :query => sign_if_needed({:token => admin_token}))
+  def empty_drop(drop_name)
+    self.class.put("/drops/#{drop_name}/empty", :query => {})
   end
 
-  def delete_drop(drop_name, admin_token)
-    self.class.delete("/drops/#{drop_name}", :query => sign_if_needed({:token => admin_token}))
+  def delete_drop(drop_name)
+    self.class.delete("/drops/#{drop_name}", :query => {})
   end
   
-  def promote_nick(drop_name, nick, admin_token)
-    self.class.post("/drops/#{drop_name}", :query => sign_if_needed({:nick => nick, :token => admin_token}))
+  def promote_nick(drop_name, nick)
+    self.class.post("/drops/#{drop_name}", :query => sign_if_needed({:nick => nick}))
   end
   
   def drop_upload_code(drop_name, token = nil)
@@ -66,15 +68,26 @@ class Dropio::Api
     self.class.post("/drops/#{drop_name}/assets", :body => sign_if_needed(params))
   end
 
-  def add_file(drop_name, file_path, description = nil, convert_to = nil, pingback_url = nil, comment = nil, token = nil)
-    url = URI.parse(Dropio::Config.upload_url)
-    r = nil
+  def add_file(drop_name, file_path, description = nil, convert_to = nil, pingback_url = nil, output_locations = nil)
+    url  = URI.parse(Dropio::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])
-      req = Net::HTTP::Post::Multipart.new url.path,
-      sign_if_needed({ 'api_key' => self.class.default_params[:api_key], 'drop_name' => drop_name, 'format' => 'json', 'description' => description,
-        'token' => token, 'version' => Dropio::Config.version, 'convert_to' => convert_to, 'pingback_url' => pingback_url,
-        'comment' => comment, 'file' => UploadIO.new(file, mime_type, file_path) })
+
+      params = sign_if_needed({
+        'api_key'           => self.class.default_params[:api_key],
+        'drop_name'         => drop_name,
+        'format'            => 'json',
+        'description'       => description,
+        'version'           => Dropio::Config.version,
+        'convert_to'        => convert_to,
+        'pingback_url'      => pingback_url,
+        'output_locations'  => locs
+      }).merge('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 Dropio::Config.debug
       r = http.start{|http| http.request(req)}
@@ -127,22 +140,18 @@ class Dropio::Api
     self.class.put("/drops/#{drop_name}/assets/#{asset_name}", :body => sign_if_needed(params))
   end
 
-  def delete_asset(drop_name, asset_name, token = nil)
-    self.class.delete("/drops/#{drop_name}/assets/#{asset_name}", :body => sign_if_needed({:token => token}))
+  def delete_asset(drop_name, asset_name)
+    self.class.delete("/drops/#{drop_name}/assets/#{asset_name}", :body => sign_if_needed({}))
+  end
+
+  def delete_role(drop_name, asset_name, role, location=nil)
+    self.class.delete("/drops/#{drop_name}/assets/#{asset_name}", :body => sign_if_needed({:role => role, :output_location => location}))
   end
 
   def send_asset_to_drop(drop_name, asset_name, target_drop, drop_token = nil, token = nil)
     self.class.post("/drops/#{drop_name}/assets/#{asset_name}/send_to", :body => sign_if_needed({:medium => "drop", :drop_name => target_drop, :token => token, :drop_token => drop_token}))
   end
   
-  def send_asset_to_fax(drop_name, asset_name, fax_number, token = nil)
-    self.class.post("/drops/#{drop_name}/assets/#{asset_name}/send_to", :body => sign_if_needed({:medium => "fax", :fax_number => fax_number, :token => token}))
-  end
-  
-  def send_asset_to_emails(drop_name, asset_name, emails, message = nil, token = nil)
-    self.class.post("/drops/#{drop_name}/assets/#{asset_name}/send_to", :body => sign_if_needed({:medium => "emails", :emails => emails, message => message, :token => token}))
-  end
-  
   def copy_asset(drop_name, asset_name, target_drop, target_drop_token, token = nil)
     params = {:token => token, :drop_name => target_drop, :drop_token => target_drop_token}
     self.class.post("/drops/#{drop_name}/assets/#{asset_name}/copy", :body => sign_if_needed(params))
@@ -153,45 +162,16 @@ class Dropio::Api
     self.class.post("/drops/#{drop_name}/assets/#{asset_name}/move", :body => sign_if_needed(params))
   end
 
-  def comments(drop_name, asset_name, page = 1, token = nil)
-    self.class.get("/drops/#{drop_name}/assets/#{asset_name}/comments", :query => sign_if_needed({:token => token, :page => page, :show_pagination_details => true}))
-  end
-
-  def create_comment(drop_name, asset_name, contents, token = nil)
-    self.class.post("/drops/#{drop_name}/assets/#{asset_name}/comments",:body => sign_if_needed({:contents => contents, :token => token}))
-  end
-
-  def comment(drop_name, asset_name, comment_id, token = nil)
-    self.class.get("/drops/#{drop_name}/assets/#{asset_name}/comments/#{comment_id}", :query => sign_if_needed({:token => token}))
-  end
-
-  def update_comment(drop_name, asset_name, comment_id, contents, admin_token)
-    self.class.put("/drops/#{drop_name}/assets/#{asset_name}/comments/#{comment_id}", :body => sign_if_needed({:contents => contents, :token => admin_token}))
-  end
-
-  def delete_comment(drop_name, asset_name, comment_id, admin_token)
-    self.class.delete("/drops/#{drop_name}/assets/#{asset_name}/comments/#{comment_id}", :body => sign_if_needed({:token => admin_token}))
-  end
-
-  def create_twitter_subscription(drop_name, username, password, message = nil, events = {}, token = nil)
-    self.class.post("/drops/#{drop_name}/subscriptions", :body => sign_if_needed({ :token => token, :type => "twitter", :username => username, :password => password, :message => message}.merge(events)))
-  end
-  
   def create_pingback_subscription(drop_name, url, events = {}, token = nil)
     self.class.post("/drops/#{drop_name}/subscriptions", :body => sign_if_needed({ :token => token, :type => "pingback", :url => url}.merge(events)))
   end
   
-  def create_email_subscription(drop_name, emails, message = nil, welcome_message = nil, welcome_subject = nil, welcome_from = nil, events = {}, token = nil)
-    params = {:token => token, :type => "email", :emails => emails, :message => message, :welcome_from => welcome_from , :welcome_subject => welcome_subject, :welcome_message => welcome_message }.merge(events)
-    self.class.post("/drops/#{drop_name}/subscriptions", :body => sign_if_needed(params))
-  end
-  
-  def subscriptions(drop_name, page, admin_token)
-    self.class.get("/drops/#{drop_name}/subscriptions", :query => sign_if_needed({:token => admin_token, :page => page, :show_pagination_details => true}))
+  def subscriptions(drop_name, page)
+    self.class.get("/drops/#{drop_name}/subscriptions", :query => sign_if_needed({:page => page, :show_pagination_details => true}))
   end
   
-  def delete_subscription(drop_name, subscription_id, admin_token)
-    self.class.delete("/drops/#{drop_name}/subscriptions/#{subscription_id}", :body => sign_if_needed({:token => admin_token}))
+  def delete_subscription(drop_name, subscription_id)
+    self.class.delete("/drops/#{drop_name}/subscriptions/#{subscription_id}", :body => {})
   end
   
   def get_signature(params={})

data/lib/dropio/asset.rb

@@ -1,8 +1,8 @@
 class Dropio::Asset < Dropio::Resource
   
   attr_accessor :drop, :name, :type, :title, :description, :filesize, :created_at,
-                :thumbnail, :status, :converted, :hidden_url, :pages, :fax_status,
-                :duration, :artist, :track_title, :height, :width, :contents, :url,
+                :thumbnail, :status, :converted, :hidden_url, :pages, :duration, 
+                :artist, :track_title, :height, :width, :contents, :url,
                 :original_filename, :converted_filename, :can_download_original,
                 :large_thumbnail, :roles, :locations
      
@@ -16,24 +16,11 @@ class Dropio::Asset < Dropio::Resource
     Dropio::Resource.client.change_asset_name(self,new_name)
   end
   
-  # Returns the comments on this Asset.  Comments are loaded lazily.  The first
-  # call to +comments+ will fetch the comments from the server.  They are then
-  # cached until the Asset is reloaded.
-  def comments(page = 1)
-    @comments = Dropio::Resource.client.comments(self, page)
-  end
-  
   # Gets the Assets's embed code
   def embed_code
     Dropio::Resource.client.asset_embed_code(self)
   end       
   
-  # Adds a comment to the Asset with the given +contents+.  Returns the
-  # new +Comment+.
-  def create_comment(contents)
-    Dropio::Resource.client.create_comment(self, contents)
-  end
-  
   # Saves the Asset back to drop.io.
   def save
     Dropio::Resource.client.update_asset(self)
@@ -42,7 +29,19 @@ class Dropio::Asset < Dropio::Resource
   # Destroys the Asset on drop.io.  Don't try to use an Asset after destroying it.
   def destroy!
     Dropio::Resource.client.delete_asset(self)
-    nil
+    return nil
+  end
+  
+  # Destroys the given role on an Asset
+  def destroy_role!(role)
+    Dropio::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)
+    Dropio::Resource.client.delete_role(self, role, location)
+    return nil
   end
   
   # Copies the Asset to the given drop. The +token+ is the target drop's token if required to add files.
@@ -55,24 +54,6 @@ class Dropio::Asset < Dropio::Resource
     Dropio::Resource.client.move_asset(self, target_drop)
   end
   
-  # Returns true if the Asset can be faxed.
-  def faxable?
-    return type.downcase == "document"
-  end
-  
-  # Fax the Asset to the given +fax_number+.  Make sure the Asset is +faxable?+
-  # first, or +send_to_fax+ will raise an error.
-  def send_to_fax(fax_number)
-    raise "Can't fax Asset: #{self.inspect} is not faxable" unless faxable?
-    Dropio::Resource.client.send_asset_to_fax(self, fax_number)
-    nil
-  end
-  
-  # Sends the Asset to the given +emails+ with an optional +message+.
-  def send_to_emails(emails = [], message = nil)
-    Dropio::Resource.client.send_asset_to_emails(self, emails, message)
-  end
-  
   # Sends the Asset to a Drop by +drop_name+
   def send_to_drop(drop)
     Dropio::Resource.client.copy_asset(self, drop)

data/lib/dropio/client.rb

@@ -22,33 +22,31 @@ class Dropio::Client
   end
   
   def change_drop_name(drop, new_name)
-    handle(:drop, self.service.change_drop_name(drop.name,drop.admin_token,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, :default_view => drop.default_view,
-               :chat_password => drop.chat_password, :guests_can_comment => drop.guests_can_comment,
-               :guests_can_add => drop.guests_can_add, :guests_can_delete => drop.guests_can_delete,
-               :expiration_length => drop.expiration_length, :password => drop.password,
-               :admin_password => drop.admin_password, :premium_code => drop.premium_code }
-    handle(:drop, self.service.update_drop(drop.name,drop.admin_token,params))
+               :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,drop.admin_token))
+    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,drop.admin_token))
+    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,drop.admin_token))
+    r = handle(:response, self.service.promote_nick(drop.name,nick))
     r["result"]
   end
   
@@ -69,8 +67,8 @@ class Dropio::Client
     a
   end
 
-  def add_file(drop, file_path, description = nil, convert_to = nil, pingback_url = nil, comment = nil)
-    a = handle(:asset, self.service.add_file(drop.name, file_path, description, convert_to, pingback_url, comment, drop.default_token))
+  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
@@ -120,22 +118,17 @@ class Dropio::Client
   end
 
   def delete_asset(asset)
-    r = handle(:response, self.service.delete_asset(asset.drop.name,asset.name,asset.drop.default_token))
+    r = handle(:response, self.service.delete_asset(asset.drop.name,asset.name))
     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, target_drop.default_token, asset.drop.default_token))
+  def delete_role(asset, role, location=nil)
+    r = handle(:response, self.service.delete_role(asset.drop.name,asset.name,role,location))
     r["result"]
   end
-  
-  def send_asset_to_fax(asset, fax_number)
-    r = handle(:response, self.service.send_asset_to_fax(asset.drop.name, asset.name, fax_number, asset.drop.default_token))
-    r["result"]
-  end
-  
-  def send_asset_to_emails(asset, emails, message)
-    r = handle(:response, self.service.send_asset_to_emails(asset.drop.name, asset.name, emails, message, asset.drop.default_token))
+
+  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, target_drop.default_token, asset.drop.default_token))
     r["result"]
   end
   
@@ -149,48 +142,6 @@ class Dropio::Client
     r["result"]
   end
 
-  def comments(asset, page = 1)
-    comments = handle(:comments, self.service.comments(asset.drop.name,asset.name,page,asset.drop.default_token))
-    comments.each{|c| c.asset = asset}
-    comments
-  end
-
-  def create_comment(asset, contents)
-    c = handle(:comment, self.service.create_comment(asset.drop.name,asset.name,contents,asset.drop.default_token))
-    c.asset = asset
-    c
-  end
-
-  def comment(asset, comment_id)
-    c = handle(:comment, self.service.comment(asset.drop.name,asset.name,comment_id,asset.drop.default_token))
-    c.asset = asset
-    c
-  end
-
-  def update_comment(comment)
-    c = handle(:comment, self.service.update_comment(comment.asset.drop.name,comment.asset.name,comment.id,comment.contents,comment.asset.drop.admin_token))
-    c.asset = comment.asset
-    c
-  end
-
-  def delete_comment(comment)
-    r = handle(:response, self.service.delete_comment(comment.asset.drop.name,comment.asset.name,comment.id,comment.asset.drop.admin_token))
-    r["result"]
-  end
-  
-  def create_twitter_subscription(drop, username,password, message, events)
-    s = handle(:subscription, self.service.create_twitter_subscription(drop.name, username, password, message, events, drop.default_token))
-    s.drop = drop
-    s
-  end
-  
-  def create_email_subscription(drop, emails, welcome_message, welcome_subject, welcome_from, message, events)
-    s = handle(:subscriptions, self.service.create_email_subscription(drop.name, emails, welcome_message, welcome_subject, welcome_from, message, events, drop.default_token))
-    s = s.first
-    s.drop = drop
-    s
-  end
-  
   def create_pingback_subscription(drop, url, events)
     s = handle(:subscription, self.service.create_pingback_subscription(drop.name, url, events, drop.default_token))
     s.drop = drop
@@ -198,7 +149,7 @@ class Dropio::Client
   end
   
   def subscriptions(drop, page = 1)
-    subscriptions = handle(:subscriptions, self.service.subscriptions(drop.name,page,drop.admin_token))
+    subscriptions = handle(:subscriptions, self.service.subscriptions(drop.name,page))
     subscriptions.each{|s| s.drop = drop}
     subscriptions
   end
@@ -220,8 +171,6 @@ class Dropio::Client
     when :drops then return response['drops'].collect{|s| Dropio::Drop.new(d)}
     when :asset then return Dropio::Asset.new(response)
     when :assets then return response['assets'].collect{|a| Dropio::Asset.new(a)}
-    when :comment then return Dropio::Comment.new(response)
-    when :comments then return response['comments'].collect{|c| Dropio::Comment.new(c)}
     when :subscription then return Dropio::Subscription.new(response)
     when :subscriptions then return response['subscriptions'].collect{|s| Dropio::Subscription.new(s)}
     when :response then return parse_response(response)

data/lib/dropio/drop.rb

@@ -1,13 +1,12 @@
 class Dropio::Drop < Dropio::Resource
   
-  attr_accessor :name, :email, :voicemail, :conference, :fax, :rss, :guest_token, :description,
-                :admin_token, :expires_at, :expiration_length, :guests_can_comment, :guests_can_add, :guests_can_delete,
-                :max_bytes, :current_bytes, :hidden_upload_url, :asset_count, :chat_password, :default_view,
-                :password, :admin_password, :premium_code, :admin_email, :email_key
+  attr_accessor :name, :email, :guest_token, :description, :expires_at, :expiration_length, 
+                :max_bytes, :current_bytes, :asset_count, :chat_password, :password, 
+                :admin_password, :admin_email, :email_key
      
   # Gets the default token to be used, prefers the admin token.           
   def default_token
-    self.admin_token || self.guest_token
+    self.guest_token
   end
   
   # Gets a list of assets associated with the Drop. Paginated at 
@@ -26,13 +25,13 @@ class Dropio::Drop < Dropio::Resource
   end
   
   # Creates a drop with an +attributes+ hash.
-  # Valid attributes: name (string), default_view (string), guests_can_comment (boolean), guests_can_add (boolean), guests_can_delete (boolean), expiration_length (string), password (string), admin_password (string), and premium_code (string)
+  # Valid attributes: name (string), expiration_length (string), password (string), and admin_password (string)
   # Descriptions can be found here: http://groups.google.com/group/dropio-api/web/full-api-documentation
   def self.create(attributes = {})
     Dropio::Resource.client.create_drop(attributes)
   end
   
-  # Changes the name of a drop. Admin token required. Has to be 7 characters or more unless premium.
+  # Changes the name of a drop.
   def change_name(new_name)
     Dropio::Resource.client.change_drop_name(self,new_name)
   end
@@ -68,8 +67,8 @@ class Dropio::Drop < Dropio::Resource
   end
   
   # Adds a file to the Drop given the +file_path+.
-  def add_file(file_path, description = nil, convert_to = nil, pingback_url = nil, comment = nil)
-    Dropio::Resource.client.add_file(self, file_path, description, convert_to, pingback_url, comment)
+  def add_file(file_path, description = nil, convert_to = nil, pingback_url = nil, output_locations = nil)
+    Dropio::Resource.client.add_file(self, file_path, description, convert_to, pingback_url, output_locations)
   end
   
   # Creates a note with a +title+ and +contents+
@@ -87,16 +86,6 @@ class Dropio::Drop < Dropio::Resource
     Dropio::Resource.client.create_pingback_subscription(self,url,events)
   end
   
-  # Creates a Twitter Subscription
-  def create_twitter_subscription(username,password,message = nil, events = {})
-   Dropio::Resource.client.create_twitter_subscription(self,username,password,message,events)
-  end
-  
-  # Creates an email Subscription
-  def create_email_subscription(email, message = nil, welcome_message = nil, welcome_subject = nil, welcome_from = nil, events = {})
-    Dropio::Resource.client.create_email_subscription(self,email,message,welcome_message,welcome_subject,welcome_from, events)
-  end
-  
   # Gets a list of Subscription objects.
   def subscriptions(page = 1)
     Dropio::Resource.client.subscriptions(self, page)

data/lib/dropio/version.rb

@@ -0,0 +1,3 @@
+module Dropio
+  VERSION = '3.0.0.pre2'
+end

data/lib/dropio.rb

@@ -1,10 +1,12 @@
+require 'dropio/version'
+
 module Dropio
-  VERSION = '3.0.0'
+  class Error < StandardError; end
   
-  class MissingResourceError < Exception; end
-  class AuthorizationError < Exception; end
-  class RequestError < Exception; end
-  class ServerError < Exception; end
+  class MissingResourceError < Error; end
+  class AuthorizationError   < Error; end
+  class RequestError         < Error; end
+  class ServerError          < Error; end
   
   class Config
     class << self
@@ -14,22 +16,16 @@ module Dropio
   
 end
 
-require 'rbconfig'
-require 'mime/types'
-require 'httparty'
-require 'net/http/post/multipart'
-
-Dropio::Config.base_url = "http://drop.io"
-Dropio::Config.api_url = "http://api.drop.io"
+Dropio::Config.base_url   = "http://drop.io"
+Dropio::Config.api_url    = "http://api.drop.io"
 Dropio::Config.upload_url = "http://assets.drop.io/upload"
-Dropio::Config.version = "3.0"
-Dropio::Config.debug = false
-Dropio::Config.timeout = 60 # Default in Ruby
+Dropio::Config.version    = "3.0"
+Dropio::Config.debug      = false
+Dropio::Config.timeout    = 60 # Default in Ruby
 
 require 'dropio/api'
 require 'dropio/client'
 require 'dropio/resource'
 require 'dropio/drop'
 require 'dropio/asset'
-require 'dropio/comment'
 require 'dropio/subscription'

data/spec/dropio/asset_spec.rb

@@ -19,25 +19,9 @@ describe Dropio::Asset do
   
   it "should have the attributes of an Asset" do
     @asset.should respond_to(:drop, :name, :type, :title, :description, :filesize, :created_at,
-                  :thumbnail, :status, :converted, :hidden_url, :pages, :fax_status,
-                  :duration, :artist, :track_title, :height, :width, :contents, :url,
-                  :original_filename, :converted_filename, :can_download_original, :large_thumbnail)
-  end
-  
-  it "should have comments" do
-    @comment = stub(Comment)
-    @comment.should_receive(:asset=).once
-    @client.should_receive(:handle).with(:comments,{}).and_return([@comment])
-    @api.stub!(:comments).with(@drop.name, @asset.name, 1, @drop.default_token).and_return({})
-    @asset.comments.should == [@comment]
-  end
-  
-  it "should create comments" do
-    @comment = stub(Comment)
-    @comment.should_receive(:asset=).once
-    @client.should_receive(:handle).with(:comment,{}).and_return(@comment)
-    @api.stub!(:create_comment).with(@drop.name, @asset.name, "Totally rad asset, bro!",@drop.default_token).and_return({})
-    @asset.create_comment("Totally rad asset, bro!").should == @comment
+                  :thumbnail, :status, :converted, :hidden_url, :pages, :duration, :artist, 
+                  :track_title, :height, :width, :contents, :url, :original_filename, :converted_filename, 
+                  :large_thumbnail)
   end
   
   it "should save itself" do
@@ -50,34 +34,20 @@ describe Dropio::Asset do
   
   it "should destroy itself" do
     @client.should_receive(:handle).with(:response,{}).and_return({"result" => "Success"})
-    @api.stub!(:delete_asset).with(@drop.name, @asset.name,@drop.default_token).and_return({})
+    @api.stub!(:delete_asset).with(@drop.name, @asset.name).and_return({})
     @asset.destroy!
   end
-  
-  it "should be faxable if and only if it's a document" do
-    @asset.type = "Document"
-    @asset.should be_faxable
-    @asset.type = "Video"
-    @asset.should_not be_faxable
-  end
-  
-  it "should fax itself to a phone number" do
-    @asset.type = "Document"
-    
+
+  it "should destroy roles" do
     @client.should_receive(:handle).with(:response,{}).and_return({"result" => "Success"})
-    @api.stub!(:send_asset_to_fax).with(@drop.name, @asset.name,"234-567-8901",@drop.default_token).and_return({})
-    @asset.send_to_fax("234-567-8901")
+    @api.stub!(:delete_role).with(@drop.name, @asset.name, "thumbnail", nil).and_return({})
+    @asset.destroy_role!("thumbnail")
   end
-  
-  it "should email itself to a comma separated list of emails with an optional message" do
-    @asset.type = "Document"
-    @client.should_receive(:handle).with(:response,{}).and_return({"result" => "Success"})
-    @api.stub!(:send_asset_to_emails).with(@drop.name, @asset.name,"jake@dropio.com, jacob@dropio.com", "Awesome stuff!", @drop.default_token).and_return({})
-    @asset.send_to_emails("jake@dropio.com, jacob@dropio.com","Awesome stuff!")
-    
+
+  it "should destroy roles at locations" do
     @client.should_receive(:handle).with(:response,{}).and_return({"result" => "Success"})
-    @api.stub!(:send_asset_to_emails).with(@drop.name, @asset.name,"jake@dropio.com, jacob@dropio.com", nil, @drop.default_token).and_return({})
-    @asset.send_to_emails("jake@dropio.com, jacob@dropio.com")
+    @api.stub!(:delete_role).with(@drop.name, @asset.name, "thumbnail", "DropioS3").and_return({})
+    @asset.destroy_location!("thumbnail","DropioS3")
   end
   
   it "should send itself to another drop." do
@@ -107,13 +77,6 @@ describe Dropio::Asset do
     @asset.move_to(@target_drop)
   end
   
-  it "should not fax itself if it's not faxable" do
-    @asset.type = "Video"
-    @api.should_not_receive(:send_asset_to_fax)
-    # TODO: Make this a specific error.
-    lambda { @asset.send_to_fax("234-567-8901") }.should raise_error
-  end
-  
   it "should find itself" do
     @client.should_receive(:handle).with(:asset,{}).and_return(@asset)
     @api.should_receive(:asset).with(@drop.name, @asset.name, @drop.default_token).and_return({})
@@ -121,7 +84,7 @@ describe Dropio::Asset do
   end
   
   it "should generate a signed url" do
-    @api.should_receive(:generate_drop_url).with(@drop.name,@asset.name,@drop.default_token)  
+    @api.should_receive(:generate_asset_url).with(@drop.name,@asset.name,@drop.default_token)
     @asset.generate_url
   end
   

data/spec/dropio/drop_spec.rb

@@ -11,14 +11,13 @@ describe Drop do
     Dropio::Resource.client.should == @client
     Dropio::Resource.client.service.should == @api
     
-    @mydrop = Dropio::Drop.new(:name => "test_drop",:admin_token => "admin_token")
+    @mydrop = Dropio::Drop.new(:name => "test_drop")
   end
   
   it "should have the attributes of a Drop" do
-    Drop.new.should respond_to(:name, :email, :voicemail, :conference, :fax, :rss, :guest_token, :description,
-                  :admin_token, :expires_at, :expiration_length, :guests_can_comment, :guests_can_add, :guests_can_delete,
-                  :max_bytes, :current_bytes, :hidden_upload_url, :asset_count, :chat_password, :default_view, 
-                  :password, :admin_password, :premium_code, :admin_email, :email_key)
+    Drop.new.should respond_to(:name, :email, :guest_token, :description, :expires_at, 
+                  :expiration_length, :max_bytes, :current_bytes, :asset_count, :chat_password, 
+                  :password, :admin_password, :admin_email, :email_key)
   end
   
   it "should find drops by name" do
@@ -33,11 +32,6 @@ describe Drop do
     Drop.find("mydrop", "d85a6").should == @mydrop
   end
   
-  it "should have a default token and it should default to the admin" do
-    @mydrop.admin_token = "tester"
-    @mydrop.default_token.should == "tester"
-  end
-  
   it "should find a set of related assets" do
     @asset = stub(Asset)
     @asset.should_receive(:drop=).once
@@ -60,29 +54,28 @@ describe Drop do
   
   it "should be able to empty itself" do
     @client.should_receive(:handle).with(:response,{}).and_return({})
-    @api.should_receive(:empty_drop).with(@mydrop.name,@mydrop.admin_token).and_return({})
+    @api.should_receive(:empty_drop).with(@mydrop.name).and_return({})
     @mydrop.empty
   end
   
   it "should be able to promote a nick" do
     @client.should_receive(:handle).with(:response,{}).and_return({"result" => "Success"})
-    @api.should_receive(:promote_nick).with(@mydrop.name,"jake",@mydrop.admin_token).and_return({})
+    @api.should_receive(:promote_nick).with(@mydrop.name,"jake").and_return({})
     @mydrop.promote("jake")
   end
   
   it "should save itself" do
     @client.should_receive(:handle).with(:drop,{}).and_return(@mydrop)
-    expected_hash = {:password=>"test_password", :expiration_length=>nil, :admin_password=>nil, :guests_can_comment=>nil, 
-                     :premium_code=>nil, :guests_can_add=>nil, :chat_password=>nil, :guests_can_delete=>nil, 
-                     :admin_email=>nil, :default_view=>nil, :email_key=>nil, :description=>nil}
-    @api.should_receive(:update_drop).with(@mydrop.name,@mydrop.admin_token,expected_hash).and_return({})
+    expected_hash = {:password=>"test_password", :expiration_length=>nil, :admin_password=>nil,  
+                     :chat_password=>nil, :admin_email=>nil, :email_key=>nil, :description=>nil}
+    @api.should_receive(:update_drop).with(@mydrop.name,expected_hash).and_return({})
     @mydrop.password = "test_password"
     @mydrop.save
   end
   
   it "should destroy itself" do
     @client.should_receive(:handle).with(:response,{}).and_return({"result" => "Success"})
-    @api.should_receive(:delete_drop).with(@mydrop.name,@mydrop.admin_token).and_return({})
+    @api.should_receive(:delete_drop).with(@mydrop.name).and_return({})
     @mydrop.destroy!
   end
   
@@ -106,17 +99,25 @@ describe Drop do
     @asset = stub(Asset)
     @asset.should_receive(:drop=).once
     @client.should_receive(:handle).with(:asset,{}).and_return(@asset)
-    @api.should_receive(:add_file).with(@mydrop.name,"/mypath/myfile.txt", "description", nil, nil, nil, @mydrop.default_token).and_return({})
+    @api.should_receive(:add_file).with(@mydrop.name,"/mypath/myfile.txt", "description", nil, nil, nil).and_return({})
     @mydrop.add_file("/mypath/myfile.txt", "description").should == @asset
   end
   
-  it "should add files from a path with pingback url and convertsion target" do
+  it "should add files from a path with pingback url and conversion target" do
     @asset = stub(Asset)
     @asset.should_receive(:drop=).once
     @client.should_receive(:handle).with(:asset,{}).and_return(@asset)
-    @api.should_receive(:add_file).with(@mydrop.name,"/mypath/myfile.txt","description", 'H264_HIGH_RES', 'http://drop.io/test/pinged', nil, @mydrop.default_token).and_return({})
+    @api.should_receive(:add_file).with(@mydrop.name,"/mypath/myfile.txt","description", 'H264_HIGH_RES', 'http://drop.io/test/pinged', nil).and_return({})
     @mydrop.add_file("/mypath/myfile.txt","description",'H264_HIGH_RES', 'http://drop.io/test/pinged').should == @asset
   end
+
+  it "should add files from a path with pingback url, conversion target, and output location" do
+    @asset = stub(Asset)
+    @asset.should_receive(:drop=).once
+    @client.should_receive(:handle).with(:asset,{}).and_return(@asset)
+    @api.should_receive(:add_file).with(@mydrop.name,"/mypath/myfile.txt","description", 'H264_HIGH_RES', 'http://drop.io/test/pinged','DropioS3').and_return({})
+    @mydrop.add_file("/mypath/myfile.txt","description",'H264_HIGH_RES', 'http://drop.io/test/pinged', 'DropioS3').should == @asset
+  end
   
   it "should create notes from title and contents and description" do
     @asset = stub(Asset)
@@ -134,22 +135,6 @@ describe Drop do
     @mydrop.create_link("http://drop.io","drop.io","The best!").should == @asset
   end
   
-  it "should be able to create a twitter subscription" do
-    @sub = stub(Subscription)
-    @sub.should_receive(:drop=).once
-    @client.should_receive(:handle).with(:subscription,{}).and_return(@sub)
-    @api.should_receive(:create_twitter_subscription).with(@mydrop.name,"mytwitter","pass",nil,{},@mydrop.default_token).and_return({})
-    @mydrop.create_twitter_subscription("mytwitter","pass")
-  end
-
-  it "should be able to create email subscriptions" do
-    @sub = stub(Subscription)
-    @sub.should_receive(:drop=).once
-    @client.should_receive(:handle).with(:subscription,{}).and_return(@sub)
-    @api.should_receive(:create_email_subscription).with(@mydrop.name,"jake@dropio.com","My welcome message",nil,nil,nil,{},@mydrop.default_token).and_return({})
-    @mydrop.create_email_subscription("jake@dropio.com","My welcome message")
-  end
-  
   it "should be able to create pingback subscriptions" do
     @sub = stub(Subscription)
     @sub.should_receive(:drop=).once
@@ -162,7 +147,7 @@ describe Drop do
     @sub = stub(Subscription)
     @sub.should_receive(:drop=).once
     @client.should_receive(:handle).with(:subscriptions,{}).and_return([@sub])
-    @api.stub!(:subscriptions).with(@mydrop.name, 1, @mydrop.admin_token).and_return({})
+    @api.stub!(:subscriptions).with(@mydrop.name, 1).and_return({})
     @mydrop.subscriptions.should == [@sub]
   end
   

data/spec/dropio_spec.rb

@@ -5,4 +5,26 @@ describe Dropio do
     Dropio::Config.api_key = "83a05513ddddb73e75c9d8146c115f7fd8e90de6"
     Dropio::Config.api_key.should == "83a05513ddddb73e75c9d8146c115f7fd8e90de6"
   end
+  
+  it "should define exceptions which inherit from StandardError" do
+    exception_names = [
+      :MissingResourceError,
+      :AuthorizationError,
+      :RequestError,
+      :ServerError
+    ]
+    
+    exceptions = exception_names.map do |n|
+      Dropio.const_get n
+    end
+    
+    exceptions.each do |e|
+      assert_nothing_raised do
+        begin
+          raise e
+        rescue StandardError
+        end
+      end
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,11 +1,14 @@
 require 'rubygems'
+require 'bundler'
+Bundler.setup :default, :test
+
 require 'spec'
+require 'spec/test/unit'
 require 'fakeweb'
 
 FakeWeb.allow_net_connect = false
 
-lib_dir = File.dirname(__FILE__) + '/../lib'
-$:.unshift lib_dir unless $:.include?(lib_dir)
+$: << File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
 
 require 'dropio'
 include Dropio

metadata

@@ -1,22 +1,22 @@
 --- !ruby/object:Gem::Specification 
 name: dropio
 version: !ruby/object:Gem::Version 
-  hash: -1876988210
+  hash: -1876988209
   prerelease: true
   segments: 
   - 3
   - 0
   - 0
-  - pre3
-  version: 3.0.0.pre3
+  - pre4
+  version: 3.0.0.pre4
 platform: ruby
 authors: 
-- Jake Good
+- Jake Good, Eric Skiff, Kunal Shah, Seth Thomas Rasmussen
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-10-01 00:00:00 -05:00
+date: 2010-08-31 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -34,12 +34,26 @@ dependencies:
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: httparty
+  name: json
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: httparty
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
       - !ruby/object:Gem::Version 
         hash: 5
         segments: 
@@ -48,11 +62,11 @@ dependencies:
         - 1
         version: 0.6.1
   type: :runtime
-  version_requirements: *id002
+  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: multipart-post
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -62,11 +76,11 @@ dependencies:
         - 0
         version: "0"
   type: :runtime
-  version_requirements: *id003
+  version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: echoe
+  name: rspec
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -76,10 +90,41 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id004
-description: A Ruby client library for the Drop.io API (http://api.drop.io). Please email jake@dropio.com with any questions.
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: diff-lcs
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: fakeweb
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id007
+description: A Ruby client library for the Drop.io Rich Media Backbone (RMB) API (http://backbone.drop.io). Please email support@dropio.com for any issues.
 email: 
 - jake@dropio.com
+- eric@dropio.com
+- kunal@dropio.com
+- seth@dropio.com
 executables: []
 
 extensions: []
@@ -89,30 +134,30 @@ extra_rdoc_files:
 - Readme.rdoc
 - Todo.rdoc
 files: 
+- 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/comment.rb
 - lib/dropio/drop.rb
 - lib/dropio/resource.rb
 - lib/dropio/subscription.rb
-- lib/dropio.rb
-- LICENSE.txt
-- Manifest
-- Rakefile
-- Readme.rdoc
+- lib/dropio/version.rb
 - spec/dropio/api_spec.rb
 - spec/dropio/asset_spec.rb
 - spec/dropio/client_spec.rb
-- spec/dropio/comment_spec.rb
 - spec/dropio/drop_spec.rb
 - spec/dropio/subscription_spec.rb
 - spec/dropio_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
-- Todo.rdoc
-- dropio.gemspec
 has_rdoc: true
 homepage: http://github.com/dropio/dropio
 licenses: []
@@ -151,7 +196,7 @@ requirements: []
 rubyforge_project: dropio
 rubygems_version: 1.3.7
 signing_key: 
-specification_version: 2
-summary: A Ruby client library for the Drop.io API (http://api.drop.io)
+specification_version: 3
+summary: A Ruby client library for the Drop.io Rich Media Backbone (RMB) API (http://backbone.drop.io)
 test_files: []
 

data/lib/dropio/comment.rb

@@ -1,15 +0,0 @@
-class Dropio::Comment < Dropio::Resource
-  
-  attr_accessor :id, :contents, :created_at, :asset
-
-  # Saves the comment back to drop.io
-  def save
-    Dropio::Resource.client.update_comment(self)
-  end
-  
-  # Destroys the comment on drop.io.  Don't try to use an Comment after destroying it.
-  def destroy!
-    Dropio::Resource.client.delete_comment(self)
-  end
-  
-end

data/spec/dropio/comment_spec.rb

@@ -1,38 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe Dropio::Comment do
-  before(:each) do
-    @drop = Dropio::Drop.new
-    @drop.name = "test_drop"
-    @asset = Dropio::Asset.new
-    @asset.drop = @drop
-    @asset.name = "test_asset"
-    @comment = Dropio::Comment.new
-    @comment.asset = @asset
-    
-    @client = Dropio::Client.new
-    @api = stub(Dropio::Api)
-    @client.service = @api
-    
-    Dropio::Resource.stub!(:client).and_return(@client)
-    Dropio::Resource.client.should == @client
-    Dropio::Resource.client.service.should == @api
-  end
-  
-  it "should have the attributes of an Comment" do
-    @comment.should respond_to(:id, :contents, :created_at)
-  end
-  
-  it "should save itself" do
-    @client.should_receive(:handle).with(:comment,{}).and_return(@comment)
-    @api.should_receive(:update_comment).with(@drop.name, @asset.name, @comment.id, "My new content", @drop.default_token).and_return({})
-    @comment.contents = "My new content"
-    @comment.save
-  end
-  
-  it "should destroy itself" do
-    @client.should_receive(:handle).with(:response,{}).and_return({"result" => "Success"})
-    @api.should_receive(:delete_comment).with(@drop.name, @asset.name, @comment.id, @drop.admin_token).and_return({})
-    @comment.destroy!
-  end
-end