dropio 0.9.0

data/History.rdoc

@@ -0,0 +1,3 @@
+=== 0.9.0 / 2008-11-10
+
+* First gem release.

data/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2008 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,22 @@
+History.rdoc
+lib/dropio/asset.rb
+lib/dropio/client/mapper.rb
+lib/dropio/client/multipart_post.rb
+lib/dropio/client.rb
+lib/dropio/comment.rb
+lib/dropio/drop.rb
+lib/dropio/resource.rb
+lib/dropio.rb
+LICENSE.txt
+Manifest
+Rakefile
+Readme.rdoc
+spec/dropio/asset_spec.rb
+spec/dropio/client/mapper_spec.rb
+spec/dropio/client_spec.rb
+spec/dropio/comment_spec.rb
+spec/dropio/drop_spec.rb
+spec/dropio_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+Todo.rdoc

data/Rakefile

@@ -0,0 +1,62 @@
+$: << 'lib'
+require 'dropio'
+
+### 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", "Peter Jaros"]
+    echoe.email = ["jake@dropio.com", "peeja@dropio.com"]
+    echoe.url = "http://github.com/whoisjake/dropio_api_ruby"
+    echoe.changelog = "History.txt"
+    echoe.ignore_pattern = "tmtags"
+    
+    # Comment out this line when building docs locally or publishing docs.
+    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,17 @@
+(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.)
+
+= 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:
+
+  Dropio.api_key = "83a05513ddddb73e75c9d8146c115f7fd8e90de6"
+
+
+== The Drop object
+
+There are two ways to get a +Drop+ object.  The first is to access an existing drop:
+
+       drop = Dropio::Drop.find("mystuff")
+  auth_drop = Dropio::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/Todo.rdoc

@@ -0,0 +1,5 @@
+== For 1.0
+* Bring spec coverage up to 100%.
+
+== Beyond
+* Provide subclasses of Asset?

data/dropio.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{dropio}
+  s.version = "0.9.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jake Good, Peter Jaros"]
+  s.date = %q{2008-11-10}
+  s.description = %q{A Ruby client library for the Drop.io API (http://api.drop.io)}
+  s.email = ["jake@dropio.com", "peeja@dropio.com"]
+  s.extra_rdoc_files = ["History.rdoc", "Readme.rdoc", "Todo.rdoc"]
+  s.files = ["History.rdoc", "lib/dropio/asset.rb", "lib/dropio/client/mapper.rb", "lib/dropio/client/multipart_post.rb", "lib/dropio/client.rb", "lib/dropio/comment.rb", "lib/dropio/drop.rb", "lib/dropio/resource.rb", "lib/dropio.rb", "LICENSE.txt", "Manifest", "Rakefile", "Readme.rdoc", "spec/dropio/asset_spec.rb", "spec/dropio/client/mapper_spec.rb", "spec/dropio/client_spec.rb", "spec/dropio/comment_spec.rb", "spec/dropio/drop_spec.rb", "spec/dropio_spec.rb", "spec/spec.opts", "spec/spec_helper.rb", "Todo.rdoc", "dropio.gemspec"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/whoisjake/dropio_api_ruby}
+  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)}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<echoe>, [">= 0"])
+    else
+      s.add_dependency(%q<echoe>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<echoe>, [">= 0"])
+  end
+end

data/lib/dropio/asset.rb

@@ -0,0 +1,60 @@
+class Dropio::Asset < Dropio::Resource
+  
+  attr_accessor :drop, :name, :type, :title, :description, :filesize, :created_at,
+                :thumbnail, :status, :file, :converted, :hidden_url, :pages,
+                :duration, :artist, :track_title, :height, :width, :contents, :url
+  
+  # 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
+    @comments = Dropio::Client.instance.find_comments(self) if @comments.nil?
+    @comments ||= []
+  end         
+  
+  # Adds a comment to the asset with the given +contents+.  Returns the
+  # new +Comment+.
+  def create_comment(contents)
+    Dropio::Client.instance.create_comment(self, contents)
+  end
+  
+  # Saves the asset back to drop.io.
+  def save
+    Dropio::Client.instance.save_asset(self)
+  end
+  
+  # Destroys the asset on drop.io.  Don't try to use an Asset after destroying it.
+  def destroy!
+    Dropio::Client.instance.destroy_asset(self)
+    nil
+  end
+  
+  # Returns true if the Asset can be faxed.
+  def faxable?
+    return type == "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::Client.instance.send_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::Client.instance.send_to_emails(self, emails, message)
+  end
+  
+  # Sends the asset to a Drop by +drop_name+
+  def send_to_drop(drop_name)
+    Dropio::Client.instance.send_to_drop(self, drop_name)
+  end
+  
+  # Generates an authenticated URL that will bypass any login action.
+  def generate_url
+    Dropio::Client.instance.generate_asset_url(self)
+  end
+  
+end

data/lib/dropio/client/mapper.rb

@@ -0,0 +1,47 @@
+class Dropio::Client::Mapper
+  
+  def self.map_drops(response_body)
+    return parse_and_map(Dropio::Drop, response_body)
+  end
+  
+  def self.map_assets(drop, response_body)
+    assets = parse_and_map(Dropio::Asset, response_body)
+    
+    assets.drop = drop if assets.is_a?(Dropio::Asset)
+    assets.each{ |a| a.drop = drop } if assets.is_a?(Array)
+    
+    return assets
+  end
+  
+  def self.map_comments(asset, response_body)
+    comments = parse_and_map(Dropio::Comment, response_body)
+    
+    comments.asset = asset if comments.is_a?(Dropio::Comment)
+    comments.each{ |c| c.asset = asset } if comments.is_a?(Array)
+    
+    return comments
+  end
+  
+  private
+  
+  def self.parse_and_map(model_class, response_body)
+    h = JSON.parse(response_body)
+    
+    # single model
+    return model_class.new(h) if h.is_a?(Hash)
+    
+    # multiple models
+    models = []
+    
+    h.each do |model_hash|
+      if model_hash.is_a?(Hash)
+        model = model_class.new(model_hash) 
+        models << model
+      end
+    end if h.is_a?(Array)
+    
+    return models
+    
+  end
+  
+end

data/lib/dropio/client/multipart_post.rb

@@ -0,0 +1,35 @@
+module Dropio::Client::MultipartPost
+  def multipart_params=(param_hash={})
+    boundary_token = [Array.new(8) {rand(256)}].join
+    self.content_type = "multipart/form-data; boundary=#{boundary_token}"
+    boundary_marker = "--#{boundary_token}\r\n"
+    self.body = param_hash.map { |param_name, param_value|
+      unless param_value.nil?
+        boundary_marker + case param_value
+        when String
+          text_to_multipart(param_name, param_value.to_s)
+        when File
+          file_to_multipart(param_name, param_value)
+        end
+      end
+    }.join('') + "--#{boundary_token}--\r\n"
+  end
+
+  protected
+  def file_to_multipart(key,file)
+    filename = File.basename(file.path)
+    mime_types = MIME::Types.of(filename)
+    mime_type = mime_types.empty? ? "application/octet-stream" : mime_types.first.content_type
+    part = "Content-Disposition: form-data; name=\"#{key}\"; filename=\"#{filename}\"\r\n"
+    part += "Content-Transfer-Encoding: binary\r\n"
+    part += "Content-Type: #{mime_type}\r\n\r\n#{file.read}\r\n"
+  end
+
+  def text_to_multipart(key,value)
+    "Content-Disposition: form-data; name=\"#{key}\"\r\n\r\n#{value}\r\n"
+  end
+end
+
+class Net::HTTP::Post
+  include Dropio::Client::MultipartPost
+end

data/lib/dropio/client.rb

@@ -0,0 +1,321 @@
+require 'rbconfig'
+
+class Dropio::Client
+  include Singleton
+  
+  # Generates a user agent string.
+  def self.user_agent_string
+    ruby_version = %w{MAJOR MINOR TEENY}.map { |k| Config::CONFIG[k] }.join(".")
+    "DropioAPI-Ruby/#{Dropio::VERSION} (Ruby #{ruby_version} #{Config::CONFIG["host"]}; +http://dropio.rubyforge.org/)"
+  end
+  
+  # The default set of headers for each request.
+  DEFAULT_HEADER = {
+      'User-Agent' => user_agent_string,
+      'Accept' => 'application/json'
+  }
+  
+  # Takes a drop name and optional token and returns a +Drop+ or errors.
+  def find_drop(drop_name, token = nil)
+    uri = URI::HTTP.build({:path => drop_path(drop_name), :query => get_request_tokens(token)})
+    req = Net::HTTP::Get.new(uri.request_uri, DEFAULT_HEADER)
+    drop = nil
+    complete_request(req) { |body| drop = Mapper.map_drops(body) }
+    drop
+  end
+  
+  # Finds a collection of +Asset+ objects for a given +Drop+.
+  def find_assets(drop, page = 1)
+    token = get_default_token(drop)
+    uri = URI::HTTP.build({:path => asset_path(drop), :query => get_request_tokens(token) + "&page=#{page}"})
+    req = Net::HTTP::Get.new(uri.request_uri, DEFAULT_HEADER)
+    assets = nil
+    complete_request(req) { |body| assets = Mapper.map_assets(drop, body) }
+    assets
+  end
+  
+  # Finds a collection of +Comment+ objects for a given +Asset+.
+  def find_comments(asset)
+    token = get_default_token(asset.drop)
+    uri = URI::HTTP.build({:path => comment_path(asset.drop, asset), :query => get_request_tokens(token)})
+    req = Net::HTTP::Get.new(uri.request_uri, DEFAULT_HEADER)
+    comments = nil
+    complete_request(req) { |body| comments = Mapper.map_comments(asset, body) }
+    comments
+  end
+  
+  # Creates a drop with an +attributes+ hash.
+  # Valid attributes: name (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)
+  # Descriptions can be found here: http://groups.google.com/group/dropio-api/web/full-api-documentation
+  def create_drop(attributes = {})
+    uri = URI::HTTP.build({:path => drop_path})
+    form = create_form(attributes)
+    req = Net::HTTP::Post.new(uri.request_uri, DEFAULT_HEADER)
+    req.set_form_data(form)
+    drop = nil
+    complete_request(req) { |body| drop = Mapper.map_drops(body) }
+    drop
+  end
+  
+  # Saves a +Drop+ back to drop.io
+  def save_drop(drop)
+    uri = URI::HTTP.build({:path => drop_path(drop) })
+    token = get_admin_token(drop)
+    form = create_form :token => token,
+                       :expiration_length => drop.expiration_length,
+                       :guests_can_comment => drop.guests_can_comment,
+                       :premium_code => drop.premium_code,
+                       :guests_can_add => drop.guests_can_add,
+                       :guests_can_delete => drop.guests_can_delete,
+                       :password => drop.password,
+                       :admin_password => drop.admin_password
+    req = Net::HTTP::Put.new(uri.request_uri, DEFAULT_HEADER)
+    req.set_form_data(form)
+    drop = nil
+    complete_request(req) { |body| drop = Mapper.map_drops(body) }
+    drop
+  end
+  
+  # Destroys a +Drop+
+  def destroy_drop(drop)
+    token = get_admin_token(drop)
+    uri = URI::HTTP.build({:path => drop_path(drop)})
+    form = create_form( { :token => token })
+    req = Net::HTTP::Delete.new(uri.request_uri, DEFAULT_HEADER)
+    req.set_form_data(form)
+    complete_request(req)
+    true
+  end
+  
+  # Adds a file to a +Drop+
+  def add_file(drop, file_path)
+    token = get_default_token(drop)
+    asset = nil
+    
+    File.open(file_path, 'r') do |file|
+      uri = URI.parse(Dropio.upload_url)
+      req = Net::HTTP::Post.new(uri.path, DEFAULT_HEADER)
+      form = create_form( { :drop_name => drop.name, :token => token , :file => file } )
+      req.multipart_params = form  
+      complete_request(req, uri.host) { |body| asset = Mapper.map_assets(drop, body) }
+    end
+    
+    asset
+  end
+  
+  # Creates a note +Asset+
+  def create_note(drop, title, contents)
+    token = get_default_token(drop)
+    uri = URI::HTTP.build({:path => asset_path(drop)})
+    form = create_form( { :token => token, :title => title, :contents => contents })
+    req = Net::HTTP::Post.new(uri.request_uri, DEFAULT_HEADER)
+    req.set_form_data(form)
+    asset = nil
+    complete_request(req) { |body| asset = Mapper.map_assets(drop, body) }
+    asset
+  end
+  
+  # Creates a link +Asset+
+  def create_link(drop, url, title = nil, description = nil)
+    token = get_default_token(drop)
+    uri = URI::HTTP.build({:path => asset_path(drop)})
+    form = create_form( { :token => token, :url => url, :title => title, :description => description })
+    req = Net::HTTP::Post.new(uri.request_uri, DEFAULT_HEADER)
+    req.set_form_data(form)
+    asset = nil
+    complete_request(req) { |body| asset = Mapper.map_assets(drop, body) }
+    asset
+  end
+  
+  # Saves a +Comment+, requires admin token.
+  def save_comment(comment)
+    token = get_default_token(comment.asset.drop)
+    uri = URI::HTTP.build({:path => comment_path(comment.asset.drop, comment.asset, comment)})
+    form = create_form( { :token => token, :contents => comment.contents })
+    req = Net::HTTP::Put.new(uri.request_uri, DEFAULT_HEADER)
+    req.set_form_data(form)
+    complete_request(req) { |body| comment = Mapper.map_comments(comment.asset, body) }
+    comment
+  end
+  
+  # Destroys a +Comment+, requires admin token.
+  def destroy_comment(comment)
+    token = get_admin_token(comment.asset.drop)
+    uri = URI::HTTP.build({:path => comment_path(comment.asset.drop, comment.asset, comment)})
+    form = create_form( { :token => token })
+    req = Net::HTTP::Delete.new(uri.request_uri, DEFAULT_HEADER)
+    req.set_form_data(form)
+    complete_request(req)
+    true
+  end
+  
+  # Creates a +Comment+
+  def create_comment(asset, contents)
+    token = get_default_token(asset.drop)
+    uri = URI::HTTP.build({:path => comment_path(asset.drop, asset)})
+    form = create_form( { :token => token, :contents => contents })
+    req = Net::HTTP::Post.new(uri.request_uri, DEFAULT_HEADER)
+    req.set_form_data(form)
+    comment = nil
+    complete_request(req) { |body| comment = Mapper.map_comments(asset, body) }
+    comment
+  end
+  
+  # Sends an +Asset+ (of type Document) to a +fax_number+
+  def send_to_fax(asset, fax_number)
+    params = { :medium => "fax", :fax_number => fax_number }
+    send_asset(asset,params)
+  end
+  
+  # Sends an email +message+, containing the +asset+ to a list of +emails+
+  def send_to_emails(asset, emails = [], message = nil)
+    params = { :medium => "email", :emails => emails.join(","), :message => message }
+    send_asset(asset,params)
+  end
+  
+  # Sends an +Asset+ to a given +Drop+ with +drop_name+
+  def send_to_drop(asset, drop_name)
+    params = { :medium => "drop", :drop_name => drop_name }
+    send_asset(asset,params)
+  end
+  
+  # Saves an +Asset+ back to drop.io
+  def save_asset(asset)
+    token = get_default_token(asset.drop)
+    uri = URI::HTTP.build({:path => asset_path(asset.drop, asset)})
+    form = create_form({ :token => token, 
+                         :title => asset.title,
+                         :url => asset.url,
+                         :description => asset.description,
+                         :contents => asset.contents })
+    req = Net::HTTP::Put.new(uri.request_uri, DEFAULT_HEADER)
+    req.set_form_data(form)
+    complete_request(req) { |body| asset = Mapper.map_assets(asset.drop, body)}
+    asset
+  end
+  
+  # Destroys an +Asset+
+  def destroy_asset(asset)
+    token = get_default_token(asset.drop)
+    uri = URI::HTTP.build({:path => asset_path(asset.drop, asset)})
+    form = create_form( { :token => token })
+    req = Net::HTTP::Delete.new(uri.request_uri, DEFAULT_HEADER)
+    req.set_form_data(form)
+    complete_request(req)
+    true
+  end
+  
+  # Generates the authenticated +Drop+ url.
+  def generate_drop_url(drop)
+    signed_url(drop)
+  end
+  
+  # Generates the authenticated +Asset+ url.
+  def generate_asset_url(asset)
+    signed_url(asset.drop, asset)
+  end
+  
+  
+  protected
+  
+  def signed_url(drop, asset = nil)
+    # 10 minute window.
+    expires = (Time.now.utc + 10*60).to_i
+    token = get_default_token(drop)
+    path = Dropio.base_url + "/#{drop.name}"
+    path += "/asset/#{asset.name}" if asset
+    path += "/from_api"
+    sig = Digest::SHA1.hexdigest("#{expires}+#{token}+#{drop.name}")
+    path + "?expires=#{expires}&signature=#{sig}"
+  end
+  
+  def create_form(options = {})
+    { :api_key => Dropio.api_key, :format => 'json', :version => '1.0' }.merge(options)
+  end
+  
+  def send_asset(asset, params = {})
+    token = get_default_token(asset.drop)
+    uri = URI::HTTP.build({:path => send_to_path(asset.drop, asset)})
+    form = create_form( { :token => token }.merge(params) )
+    req = Net::HTTP::Post.new(uri.request_uri, DEFAULT_HEADER)
+    req.set_form_data(form)
+    complete_request(req)
+    true
+  end
+  
+  def get_default_token(drop)
+    drop.admin_token || drop.guest_token
+  end
+  
+  def get_admin_token(drop)
+    drop ? drop.admin_token : nil
+  end
+  
+  def get_request_tokens(token = '')
+    "api_key=#{Dropio.api_key}&token=#{token}&version=1.0&format=json"
+  end
+  
+  # Creates a path directly to a comment resource or a collection of comments.
+  def comment_path(drop, asset, comment = nil)
+    comment_id = (comment) ? comment.id.to_s : ''
+    return asset_path(drop,asset) + "/comments/" + comment_id
+  end
+  
+  # Creates a path directly to an asset resource or collection of assets.
+  def asset_path(drop, asset = nil)
+    asset_name = (asset) ? asset.name : ''
+    return drop_path(drop) + "/assets/" + asset_name
+  end
+  
+  # Creates a path directly to a drop resource or collection of drops.
+  def drop_path(drop = nil)
+    drop_name = case drop
+    when Dropio::Drop
+      drop.name
+    when String
+      drop
+    when nil
+      ''
+    else
+      raise ArgumentError, "Client#drop_path takes a Drop or a String, got #{drop.inspect}"
+    end
+    
+    return "/drops/" + drop_name
+  end
+  
+  # Creates a path for sending an +Asset+
+  def send_to_path(drop, asset)
+    return asset_path(drop, asset) + "/send_to"
+  end
+    
+  # Starts and completes the given request. Returns or yields the response body.
+  def complete_request(request, host = URI.parse(Dropio.api_url).host)
+    http = Net::HTTP.new(host)
+    # Set to debug http output.
+    # http.set_debug_output $stderr
+    response = http.start { |http| http.request(request) }
+
+    case response
+    when Net::HTTPSuccess     then yield response.body if block_given?
+    when Net::HTTPBadRequest  then raise Dropio::RequestError, parse_error_message(response)
+    when Net::HTTPForbidden   then raise Dropio::AuthorizationError, parse_error_message(response)
+    when Net::HTTPNotFound    then raise Dropio::MissingResourceError, parse_error_message(response)
+    when Net::HTTPServerError then raise Dropio::ServerError, "There was a problem connecting to Drop.io."
+    else                           raise "Received an unexpected HTTP response: #{response}"
+    end
+    
+    response.body
+  end
+  
+  # Extracts the error message from the response for the exception.
+  def parse_error_message(response)
+    error_hash = JSON.parse(response.body) rescue nil
+    
+    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 Drop.io."
+    end
+  end
+  
+end

data/lib/dropio/comment.rb

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