dropio 0.9.1 → 1.0

data/lib/dropio/client.rb

@@ -1,316 +1,214 @@
-require 'rbconfig'
-
 class Dropio::Client
-  include Singleton
+  attr_accessor :service
   
-  # 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/)"
+  def initialize
+    self.service = Dropio::Api.new
   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
+  def drop(drop_name, token = nil)
+    handle(:drop, self.service.drop(drop_name, token))
   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
+  def generate_drop_url(drop)
+    self.service.generate_drop_url(drop.name,drop.default_token)
   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
+
+  def create_drop(params = {})
+    handle(:drop, self.service.create_drop(params))
   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
+
+  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))
   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
+  def empty_drop(drop)
+    r = handle(:response, self.service.empty_drop(drop.name,drop.admin_token))
+    r["result"]
   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
+
+  def delete_drop(drop)
+    r = handle(:response, self.service.delete_drop(drop.name,drop.admin_token))
+    r["result"]
   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
+  def promote_nick(drop,nick)
+    r = handle(:response, self.service.promote_nick(drop.name,nick,drop.admin_token))
+    r["result"]
   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
+  def drop_upload_code(drop)
+    r = handle(:response, self.service.drop_upload_code(drop.name,drop.default_token))
+    r["upload_code"]
   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
+    a = handle(:asset, self.service.create_link(drop.name, url, title, description, drop.default_token))
+    a.drop = drop
+    a
   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
+
+  def create_note(drop, contents, title = nil)
+    a = handle(:asset, self.service.create_note(drop.name, contents, title, drop.default_token))
+    a.drop = drop
+    a
   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
+
+  def add_file(drop, file_path, comment = nil)
+    a = handle(:asset, self.service.add_file(drop.name, file_path, drop.default_token, comment))
+    a.drop = drop
+    a
   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
+  def add_file_from_url(drop, url)
+    a = handle(:asset, self.service.add_file_from_url(drop.name, url, drop.default_token))
+    a.drop = drop
+    a
   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)
+
+  def assets(drop, page = 1, order = :oldest)
+    assets = handle(:assets, self.service.assets(drop.name,page,order,drop.default_token))
+    assets.each{|a| a.drop = drop}
+    assets
   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)
+
+  def asset(drop, asset_name)
+    a = handle(:asset, self.service.asset(drop.name,asset_name,drop.default_token))
+    a.drop = drop
+    a
   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)
+  def generate_asset_url(asset)
+    self.service.generate_drop_url(asset.drop.name, asset.name, asset.drop.default_token)
   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
+
+  def asset_embed_code(asset)
+    r = handle(:response, self.service.asset_embed_code(asset.drop.name,asset.name,asset.drop.default_token))
+    r["embed_code"]
   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
+
+  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,asset.drop.default_token))
+    a.drop = asset.drop
+    a
   end
-  
-  # Generates the authenticated +Drop+ url.
-  def generate_drop_url(drop)
-    signed_url(drop)
+
+  def delete_asset(asset)
+    r = handle(:response, self.service.delete_asset(asset.drop.name,asset.name,asset.drop.default_token))
+    r["result"]
   end
-  
-  # Generates the authenticated +Asset+ url.
-  def generate_asset_url(asset)
-    signed_url(asset.drop, asset)
+
+  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
   
-  
-  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}"
+  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 create_form(options = {})
-    { :api_key => Dropio.api_key, :format => 'json', :version => '1.0' }.merge(options)
+  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))
+    r["result"]
   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
+  def copy_asset(asset,target_drop)
+    r = handle(:response, self.service.copy_asset(asset.drop.name,asset.name,target_drop.name,target_drop.default_token,asset.drop.default_token))
+    r["result"]
   end
-  
-  def get_default_token(drop)
-    drop.admin_token || drop.guest_token
+
+  def move_asset(asset,target_drop)
+    r = handle(:response, self.service.move_asset(asset.drop.name,asset.name,target_drop.name,target_drop.default_token,asset.drop.default_token))
+    r["result"]
   end
-  
-  def get_admin_token(drop)
-    drop ? drop.admin_token : nil
+
+  def comments(asset)
+    comments = handle(:comments, self.service.comments(asset.drop.name,asset.name,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 get_request_tokens(token = '')
-    "api_key=#{Dropio.api_key}&token=#{token}&version=1.0&format=json"
+  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
   
-  # 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
+  def create_email_subscription(drop, emails, welcome_message, welcome_subject, welcome_from, message, events)
+    s = handle(:subscription, self.service.create_email_subscription(drop.name, emails, welcome_message, welcome_subject, welcome_from, message, events, drop.default_token))
+    s.drop = drop
+    s
   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
+  def subscriptions(drop)
+    subscriptions = handle(:subscriptions, self.service.subscriptions(drop.name, drop.admin_token))
+    subscriptions.each{|s| s.drop = drop}
+    subscriptions
   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}"
+  private
+  
+  def handle(type, response)
+    if response.code != 200
+      parse_response(response)
     end
     
-    return "/drops/" + drop_name
+    case type
+    when :drop then return Dropio::Drop.new(response)
+    when :asset then return Dropio::Asset.new(response)
+    when :assets then return response.collect{|a| Dropio::Asset.new(a)}
+    when :comment then return Comment.new(response)
+    when :comments then return response.collect{|c| Dropio::Comment.new(c)}
+    when :subscription then return Dropio::Subscription.new(response)
+    when :subscriptions then return response.collect{|s| Dropio::Subscription.new(s)}
+    when :response then return parse_response(response)
+    end
   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}"
+  def parse_response(response)
+    case response.code
+    when 200 then return response
+    when 400 then raise Dropio::RequestError, parse_error_message(response)
+    when 403 then raise Dropio::AuthorizationError, parse_error_message(response)
+    when 404 then raise Dropio::MissingResourceError, parse_error_message(response)
+    when 500 then raise Dropio::ServerError, "There was a problem connecting to Drop.io."
+    else
+      raise "Received an unexpected HTTP response: #{response.code} #{response.body}"
     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
-    
+  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
@@ -318,4 +216,4 @@ class Dropio::Client
     end
   end
   
-end
+end

data/lib/dropio/comment.rb

@@ -4,12 +4,12 @@ class Dropio::Comment < Dropio::Resource
   
   # Saves the comment back to drop.io
   def save
-    Dropio::Client.instance.save_comment(self)
+    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::Client.instance.destroy_comment(self)
+  def destroy!
+    Dropio::Resource.client.delete_comment(self)
   end
   
 end

data/lib/dropio/drop.rb

@@ -1,54 +1,95 @@
 class Dropio::Drop < Dropio::Resource
   
-  attr_accessor :name, :email, :voicemail, :conference, :fax, :rss, :guest_token,
-                :admin_token, :expiration_length, :guests_can_comment, :guests_can_add, :guests_can_delete,
-                :max_bytes, :current_bytes, :hidden_upload_url, :upload_url, :password, :admin_password, :premium_code
+  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
+     
+  # Gets the default token to be used, prefers the admin token.           
+  def default_token
+    self.admin_token || self.guest_token
+  end
   
   # Gets a list of assets associated with the Drop. Paginated at 
-  def assets(page = 1)
-    Dropio::Client.instance.find_assets(self, page)
+  def assets(page = 1, order = :oldest)
+    Dropio::Resource.client.assets(self, page, order)
   end
   
   # Finds a drop with +name+ and optional authorization +token+
   def self.find(name, token = nil)
-    Dropio::Client.instance.find_drop(name, token)
+    Dropio::Resource.client.drop(name, token)
   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)
+  # 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)
   # Descriptions can be found here: http://groups.google.com/group/dropio-api/web/full-api-documentation
   def self.create(attributes = {})
-    Dropio::Client.instance.create_drop(attributes)
+    Dropio::Resource.client.create_drop(attributes)
+  end
+  
+  # Gets the drop's embeddable uploader code
+  def upload_code
+    Dropio::Resource.client.drop_upload_code(self)
+  end
+  
+  # Empties the drop, including it's assets.
+  def empty
+    Dropio::Resource.client.empty_drop(self)
+  end
+  
+  # Promotes a nickname in the drop chat to admin.
+  def promote(nick)
+    Dropio::Resource.client.promote_nick(self,nick)
   end
   
   # Saves the Drop.
   def save
-    Dropio::Client.instance.save_drop(self)
+    Dropio::Resource.client.update_drop(self)
   end
   
   # Deletes the Drop from the system including all associated assets.
-  def destroy
-    Dropio::Client.instance.destroy_drop(self)
+  def destroy!
+    Dropio::Resource.client.delete_drop(self)
+  end
+  
+  # Adds a file to the Drop from a given +url+
+  def add_file_from_url(url)
+    Dropio::Resource.client.add_file_from_url(self,url)
   end
   
   # Adds a file to the Drop given the +file_path+.
-  def add_file(file_path)
-    Dropio::Client.instance.add_file(self, file_path)
+  def add_file(file_path, comment = nil)
+    Dropio::Resource.client.add_file(self, file_path, comment)
   end
   
   # Creates a note with a +title+ and +contents+
-  def create_note(title,contents)
-    Dropio::Client.instance.create_note(self, title, contents)
+  def create_note(contents, title = nil)
+    Dropio::Resource.client.create_note(self, contents, title)
   end
   
   # Creates a link with a +url+, +title+, and +description+.
   def create_link(url, title = nil, description = nil)
-    Dropio::Client.instance.create_link(self, url, title, description)
+    Dropio::Resource.client.create_link(self, url, title, description)
+  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
+    Dropio::Resource.client.subscriptions(self)
   end
   
   # Generates an authenticated URL that will bypass any login action.
   def generate_url
-    Dropio::Client.instance.generate_drop_url(self)
+    Dropio::Resource.client.generate_drop_url(self)
   end
   
 end

data/lib/dropio/resource.rb

@@ -5,5 +5,9 @@ class Dropio::Resource
       self.send("#{key}=", val) if self.respond_to? key
     end
   end
+
+  def self.client
+    @@client ||= Dropio::Client.new
+  end
   
 end

data/lib/dropio/subscription.rb

@@ -0,0 +1,15 @@
+class Dropio::Subscription < Dropio::Resource
+  attr_accessor :id, :username, :message, :type
+  
+  # Fetches a single Subscription
+  def self.find(id)
+    Dropio::Resource.client.subscription(id)
+  end
+  
+  # Destroys the given subscription. Admin +token+ required
+  def destroy!(token)
+    Dropio::Resource.client.delete_subscription(self,token)
+    nil
+  end
+  
+end