dropio 0.9.1 → 1.0

data/History.rdoc

@@ -1,3 +1,15 @@
+=== 1.0.0 / 2009-10-02
+
+* Moved to API version 2.0
+
+=== 0.9.6 / 2009-10-01
+
+* Removed original file attribute from gem.
+
+=== 0.9.5 / 2009-09-09
+
+* Move gem to github.
+
 === 0.9.0 / 2008-11-10
 
 * First gem release.

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2008 Drop.io, Inc.
+Copyright (c) 2009 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,21 +1,22 @@
 History.rdoc
+lib/dropio/api.rb
 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/subscription.rb
 lib/dropio.rb
 LICENSE.txt
 Manifest
 Rakefile
 Readme.rdoc
+spec/dropio/api_spec.rb
 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/subscription_spec.rb
 spec/dropio_spec.rb
 spec/spec.opts
 spec/spec_helper.rb

data/Rakefile

@@ -7,9 +7,9 @@ begin
 
   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.author = ["Jake Good"]
+    echoe.email = ["jake@dropio.com"]
+    echoe.url = "http://github.com/dropio/dropio"
     echoe.changelog = "History.rdoc"
     echoe.ignore_pattern = "tmtags"
     echoe.runtime_dependencies = ["mime-types", "json"]

data/Readme.rdoc

@@ -4,7 +4,7 @@
 
 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"
+  Dropio::Config.api_key = "83a05513ddddb73e75c9d8146c115f7fd8e90de6"
 
 
 == The Drop object

data/dropio.gemspec

@@ -2,17 +2,17 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dropio}
-  s.version = "0.9.1"
+  s.version = "1.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-11}
-  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.authors = ["Jake Good"]
+  s.date = %q{2009-09-09}
+  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.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.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.homepage = %q{http://github.com/whoisjake/dropio_api_ruby}
+  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}
@@ -25,16 +25,19 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<mime-types>, [">= 0"])
-      s.add_runtime_dependency(%q<json>, [">= 0"])
+      s.add_runtime_dependency(%q<httparty>, [">= 0"])
+      s.add_runtime_dependency(%q<multipart-post>,[">= 0"])
       s.add_development_dependency(%q<echoe>, [">= 0"])
     else
       s.add_dependency(%q<mime-types>, [">= 0"])
-      s.add_dependency(%q<json>, [">= 0"])
+      s.add_dependency(%q<httparty>, [">= 0"])
+      s.add_dependency(%q<multipart-post>, [">= 0"])
       s.add_dependency(%q<echoe>, [">= 0"])
     end
   else
     s.add_dependency(%q<mime-types>, [">= 0"])
-    s.add_dependency(%q<json>, [">= 0"])
+    s.add_dependency(%q<httparty>, [">= 0"])
+    s.add_dependency(%q<multipart-post>, [">= 0"])
     s.add_dependency(%q<echoe>, [">= 0"])
   end
 end

data/lib/dropio/api.rb

@@ -0,0 +1,169 @@
+require 'rbconfig'
+
+class Dropio::Api
+  include HTTParty
+  format :json
+  
+  RUBY_VERSION = %w{MAJOR MINOR TEENY}.map { |k| Config::CONFIG[k] }.join(".")
+  USER_AGENT_STRING = "DropioAPI-Ruby/#{Dropio::VERSION} (Ruby #{RUBY_VERSION} #{Config::CONFIG["host"]}; +http://github.com/dropio/dropio/tree/)"
+  headers 'Accept' => 'application/json', 'User-Agent' => USER_AGENT_STRING
+
+  def initialize
+    self.class.default_params :api_key => Dropio::Config.api_key, :version => Dropio::Config.version, :format => "json"
+    self.class.base_uri Dropio::Config.api_url
+  end
+
+  def drop(drop_name, token = nil)
+    self.class.get("/drops/#{drop_name}", :query => {:token => token})
+  end
+  
+  def generate_drop_url(drop_name, token)
+    signed_url(drop_name,token)
+  end
+
+  def create_drop(params = {})
+    self.class.post("/drops",:body => params)
+  end
+
+  def update_drop(drop_name, admin_token, params = {})
+    params[:token] = admin_token
+    self.class.put("/drops/#{drop_name}", :body => params)
+  end
+  
+  def empty_drop(drop_name, admin_token)
+    self.class.put("/drops/#{drop_name}/empty", :query => {:token => admin_token})
+  end
+
+  def delete_drop(drop_name, admin_token)
+    self.class.delete("/drops/#{drop_name}", :query => {:token => admin_token})
+  end
+  
+  def promote_nick(drop_name, nick, admin_token)
+    self.class.post("/drops/#{drop_name}", :query => {:nick => nick, :token => admin_token})
+  end
+  
+  def drop_upload_code(drop_name, token = nil)
+    self.class.get("/drops/#{drop_name}/upload_code", :query => {:token => token})
+  end
+
+  def create_link(drop_name, url, title = nil, description = nil, token = nil)
+    self.class.post("/drops/#{drop_name}/assets", :body => {:url => url, :title => title, :description => description, :token => token})
+  end
+
+  def create_note(drop_name, contents, title = nil, token = nil)
+    params = {:contents => contents, :title => title, :token => token}
+    self.class.post("/drops/#{drop_name}/assets", :body => params)
+  end
+
+  def add_file(drop_name, file_path, comment = nil, token = nil)
+    url = URI.parse("http://assets.drop.io/upload/")
+    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,
+      { 'api_key' => self.class.default_params[:api_key], 'drop_name' => drop_name, 'format' => 'json',
+        'token' => token, 'version' => '2.0', 'comment' => comment, 'file' => UploadIO.new(file, mime_type, file_path) }
+      http = Net::HTTP.new(url.host, url.port)
+      r = http.start{|http| http.request(req)}
+    end
+
+    (r.nil? or r.body.nil? or r.body.empty?) ? [] : HTTParty::Response.new(Crack::JSON.parse(r.body), r.body, r.code, r.message, r.to_hash)
+  end
+  
+  def add_file_from_url(drop_name, url, token = nil)
+    self.class.post("/drops/#{drop_name}/assets", :body => {:token => token, :file_url => url})
+  end
+
+  def assets(drop_name, page = 1, order = :oldest, token = nil)
+    self.class.get("/drops/#{drop_name}/assets", :query => {:token => token, :page => page, :order => order.to_s})
+  end
+
+  def asset(drop_name, asset_name, token = nil)
+    self.class.get("/drops/#{drop_name}/assets/#{asset_name}", :query => {:token => token})
+  end
+  
+  def generate_asset_url(drop_name, asset_name, token)
+    signed_url(drop_name, token, asset_name)
+  end
+
+  def asset_embed_code(drop_name, asset_name, token = nil)
+    self.class.get("/drops/#{drop_name}/assets/#{asset_name}/embed_code", :query => {:token => token})
+  end
+
+  def update_asset(drop_name, asset_name, params = {}, token = nil)
+    params[:token] = token
+    self.class.put("/drops/#{drop_name}/assets/#{asset_name}", :body => params)
+  end
+
+  def delete_asset(drop_name, asset_name, token = nil)
+    self.class.delete("/drops/#{drop_name}/assets/#{asset_name}", :body => {:token => token})
+  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 => {: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 => {: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 => {: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 => params)
+  end
+  
+  def move_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}/move", :body => params)
+  end
+
+  def comments(drop_name, asset_name, token = nil)
+    self.class.get("/drops/#{drop_name}/assets/#{asset_name}/comments", :query => {:token => token})
+  end
+
+  def create_comment(drop_name, asset_name, contents, token = nil)
+    self.class.post("/drops/#{drop_name}/assets/#{asset_name}/comments",:body => {: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 => {: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 => {: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 => {: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 => { :token => token, :type => "twitter", :username => username, :password => password, :message => message}.merge(events))
+  end
+  
+  def create_email_subscription(drop_name, emails, welcome_message = nil, welcome_subject = nil, welcome_from = nil, message = nil, events = {}, token = nil)
+    params = {:token => token, :type => "email", :emails => emails, :welcome_from => welcome_from , :welcome_subject => welcome_subject, :welcome_message => welcome_message }.merge(events)
+    self.class.post("/drops/#{drop_name}/subscriptions", :body => params)
+  end
+  
+  def subscriptions(drop_name, admin_token)
+    self.class.get("/drops/#{drop_name}/subscriptions", :query => {:token => admin_token})
+  end
+  
+  
+  private
+  
+  def signed_url(drop_name, token, asset_name = nil)
+    # 10 minute window.
+    expires = (Time.now.utc + 10*60).to_i
+    path = Dropio::Config.base_url + "/#{drop_name}"
+    path += "/asset/#{asset_name}" if asset_name
+    path += "/from_api"
+    sig = Digest::SHA1.hexdigest("#{expires}+#{token}+#{drop_name}")
+    path + "?expires=#{expires}&signature=#{sig}"
+  end
+end

data/lib/dropio/asset.rb

@@ -1,60 +1,80 @@
 class Dropio::Asset < Dropio::Resource
   
   attr_accessor :drop, :name, :type, :title, :description, :filesize, :created_at,
-                :thumbnail, :status, :file, :converted, :hidden_url, :pages,
+                :thumbnail, :status, :converted, :hidden_url, :pages, :fax_status,
                 :duration, :artist, :track_title, :height, :width, :contents, :url
+     
+  # Finds a particular Asset by drop and asset name.
+  def self.find(drop, name)
+    Dropio::Resource.client.asset(drop,name)
+  end
   
-  # Returns the comments on this asset.  Comments are loaded lazily.  The first
+  # 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.
+  # cached until the Asset is reloaded.
   def comments
-    @comments = Dropio::Client.instance.find_comments(self) if @comments.nil?
+    @comments = Dropio::Resource.client.comments(self) if @comments.nil?
     @comments ||= []
-  end         
+  end
   
-  # Adds a comment to the asset with the given +contents+.  Returns the
+  # 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::Client.instance.create_comment(self, contents)
+    Dropio::Resource.client.create_comment(self, contents)
   end
   
-  # Saves the asset back to drop.io.
+  # Saves the Asset back to drop.io.
   def save
-    Dropio::Client.instance.save_asset(self)
+    Dropio::Resource.client.update_asset(self)
   end
   
-  # Destroys the asset on drop.io.  Don't try to use an Asset after destroying it.
+  # Destroys the Asset on drop.io.  Don't try to use an Asset after destroying it.
   def destroy!
-    Dropio::Client.instance.destroy_asset(self)
+    Dropio::Resource.client.delete_asset(self)
     nil
   end
   
+  # Copies the Asset to the given drop. The +token+ is the target drop's token if required to add files.
+  def copy_to(target_drop)
+    Dropio::Resource.client.copy_asset(self, target_drop)
+  end
+  
+  # Moves the Asset to the given drop. The +token+ is the target drop's token if required to add files.
+  def move_to(target_drop)
+    Dropio::Resource.client.move_asset(self, target_drop)
+  end
+  
   # Returns true if the Asset can be faxed.
   def faxable?
-    return type == "Document"
+    return type.downcase == "document"
   end
   
-  # Fax the asset to the given +fax_number+.  Make sure the Asset is +faxable?+
+  # 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)
+    Dropio::Resource.client.send_asset_to_fax(self, fax_number)
     nil
   end
   
-  # Sends the asset to the given +emails+ with an optional +message+.
+  # 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)
+    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_name)
-    Dropio::Client.instance.send_to_drop(self, drop_name)
+  # Sends the Asset to a Drop by +drop_name+
+  def send_to_drop(drop)
+    Dropio::Resource.client.send_asset_to_drop(self, drop)
   end
   
   # Generates an authenticated URL that will bypass any login action.
   def generate_url
-    Dropio::Client.instance.generate_asset_url(self)
+    Dropio::Resource.client.generate_asset_url(self)
   end
   
 end