matthooks-vimeo 0.1.2 → 0.2.0

data/CHANGELOG.rdoc

@@ -0,0 +1,10 @@
+== 0.2.0, released 2009-01-06
+
+* Major re-factor of each request method.
+* Separated the simple and advanced APIs into their own modules.
+* Added some documentation.
+* Updated the README.
+
+== 0.1.2, released 2008-10-26
+
+* Initial release

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Matt Hooks
+
+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/README.rdoc

@@ -0,0 +1,169 @@
+= Vimeo API Gem
+
+This gem implements a full-featured ruby interface for the Vimeo API.
+
+Vimeo's API documentation is, in my opinion, pretty poor. I've done my best to implement all the functions that are described {here}[http://vimeo.com/api-docs/advanced-api-docs.html]. There are some extra functions described {here}[http://vimeo.com/api/sandbox], but I can't be 100% sure what the correct parameters are for each method, so I'm going to omit them for the time being.
+
+== Install
+
+If you haven't already, add github's gem server to your sources:
+
+  gem sources -a http://gems.github.com
+
+Then, it's as easy as:
+
+  sudo gem install matthooks-vimeo
+
+Add the gem plugin to your Rails project by adding the following to your @environment.rb@ file:
+
+  config.gem "matthooks-vimeo", :lib => "vimeo"
+
+== Use
+
+There are two modules:
+
+  Vimeo::Simple
+  Vimeo::Advanced
+
+== Simple API
+
+The wrapper for the Simple API consists of the following classes and methods:
+
+=== Vimeo::Simple::User
+
+  Vimeo::Simple::User.info(username)
+  Vimeo::Simple::User.clips(username)
+  Vimeo::Simple::User.likes(username)
+  Vimeo::Simple::User.appears_in(username)
+  Vimeo::Simple::User.all_clips(username)
+  Vimeo::Simple::User.subscriptions(username)
+  Vimeo::Simple::User.albums(username)
+  Vimeo::Simple::User.channels(username)
+  Vimeo::Simple::User.groups(username)
+  Vimeo::Simple::User.contacts_clips(username)
+  Vimeo::Simple::User.contacts_like(username)
+
+=== Vimeo::Simple::Clip
+
+  Vimeo::Simple::Clip.info(video_id)
+
+=== Vimeo::Simple::Activity
+
+  Vimeo::Simple::Activity.user_did(username)
+  Vimeo::Simple::Activity.happened_to_user(username)
+  Vimeo::Simple::Activity.contacts_did(username)
+  Vimeo::Simple::Activity.happened_to_contacts(username)
+  Vimeo::Simple::Activity.everyone_did(username)
+
+=== Vimeo::Simple::Group
+
+  Vimeo::Simple::Group.clips(groupname)
+  Vimeo::Simple::Group.users(groupname)
+  Vimeo::Simple::Group.info(groupname)
+
+=== Vimeo::Simple::Channel
+
+  Vimeo::Simple::Channel.clips(channelname)
+  Vimeo::Simple::Channel.info(channelname)
+
+=== Vimeo::Simple::Album
+
+  Vimeo::Simple::Album.clips(album_id)
+  Vimeo::Simple::Album.info(album_id)
+
+== Advanced API
+
+The classes in Vimeo::Advanced must be instantiated with an your application's api key and secret. For example,
+
+  vimeo_video = Vimeo::Advanced::Video.new("api_key", "secret")
+
+Then you can make calls on the instance:
+
+  vimeo_video.get_list("matthooks", :page => 2, :per_page => 50)
+
+The wrapper for the Advanced API consists of the following classes and methods:
+
+=== Vimeo::Advanced::Auth
+
+  get_token(frob)
+  get_frob
+  check_token(auth_token)
+
+=== Vimeo::Advanced::Test
+
+  echo(options={})
+  null(auth_token)
+  login(auth_token)
+
+=== Vimeo::Advanced::Video
+
+  get_list(user_id, options={ :page => 1, :per_page => 25, :full_response => 0 })
+  get_uploaded_list(user_id, options={ :page => 1, :per_page => 25, :full_response => 0, :auth_token => nil })
+  get_appears_in_list(user_id, options={ :page => 1, :per_page => 25, :full_response => 0, :auth_token => nil })
+  get_subscriptions_list(user_id, options={ :page => 1, :per_page => 25, :full_response => 0, :auth_token => nil })
+  get_list_by_tag(tag, options={ :page => 1, :per_page => 25, :full_response => 0, :auth_token => nil })@
+  get_like_list(user_id, options={ :page => 1, :per_page => 25, :full_response => 0, :auth_token => nil })@
+  get_contacts_list(user_id, options={ :page => 1, :per_page => 25, :full_response => 0, :auth_token => nil })
+  get_contacts_like_list(user_id, options={ :page => 1, :per_page => 25, :full_response => 0, :auth_token => nil })
+  search(q, options={ :page => 1, :per_page => 25, :full_response => 0, :auth_token => nil })
+  get_info(video_id, auth_token=nil)
+  delete(video_id, auth_token)
+  get_thumbnail_url(video_id, size=100)
+  set_title(video_id, title, auth_token)
+  set_caption(video_id, caption, auth_token)
+  set_favorite(video_id, favorite, auth_token)
+  add_tags(video_id, tags, auth_token)
+  remove_tag(video_id, tag_id, auth_token)
+  clear_tags(video_id, auth_token)
+  add_cast(video_id, user_id, auth_token, options={})
+  get_cast(video_id, auth_token=nil)
+  remove_cast(video_id, user_id, auth_token)
+  set_privacy(video_id, privacy, auth_token)
+  get_comments_list(video_id)
+  add_comment(video_id, comment_text, auth_token, options={})
+  delete_comment(video_id, comment_id, auth_token)
+  edit_comment(video_id, comment_id, comment_text, auth_token)
+
+=== Vimeo::Advanced::Person
+
+  find_by_user_name(username)
+  find_by_email(find_email)
+  get_info(user_id)
+  get_portrait_url(user_id, options={})
+  add_contact(user_id, auth_token)
+  remove_contact(user_id, auth_token)
+  get_upload_status(user_id, auth_token)
+  add_subscription(user_id, type, auth_token)
+  remove_subscription(user_id, type, auth_token)
+
+=== Vimeo::Advanced::Contact
+
+  get_list(user_id)
+
+=== Vimeo::Advanced::Group
+
+  get_members(group_id)
+
+=== Vimeo::Advanced::Upload
+
+  get_upload_ticket(auth_token)
+  check_upload_status(ticket_id, auth_token)
+
+== Todo
+
+* Implement options that allow you to specify a format (xml, json, PHP). Right now this is slightly complicated by the fact that Vimeo returns text/html for json and not application/json, so HTTParty can't auto-detect the content-type.
+* Better initialize method for the advanced api that takes the auth_token into account.
+* Define a method that returns the correct form URL for uploading videos.
+* video_set_privacy needs the ability to specify users.
+* Some methods are not implemented by vimeo or don't seem to work.
+* Input verification? The alternative is to just let vimeo handle it.
+* May need to escape input in several cases
+* More re-factoring.
+* Tests
+
+== Thanks to
+
+* {HTTParty}[http://github.com/jnunemaker/httparty/tree/master]: Easily one of the best tools I have used since I started using Ruby.
+* {Jeweler}[http://github.com/technicalpickles/jeweler/tree/master]: Great tool for creating gems for github.
+
+=== Copyright (c) 2008 Matt Hooks. See LICENSE for details.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: matthooks-vimeo
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors: 
 - Matt Hooks
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-12-29 00:00:00 -08:00
+date: 2009-01-06 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -19,7 +19,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.2.4
+        version: 0.2.6
     version: 
 description: A full featured Ruby implementation of the Vimeo API.
 email: matthooks@gmail.com
@@ -27,19 +27,22 @@ executables: []
 
 extensions: []
 
-extra_rdoc_files: []
-
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE
+- CHANGELOG.rdoc
 files: 
-- README.textile
-- VERSION.yml
-- lib/vimeo.rb
-- test/test_helper.rb
-- test/vimeo_test.rb
-has_rdoc: false
+- README.rdoc
+- LICENSE
+- CHANGELOG.rdoc
+has_rdoc: true
 homepage: http://github.com/matthooks/vimeo
 post_install_message: 
-rdoc_options: []
-
+rdoc_options: 
+- --main
+- README.rdoc
+- --inline-source
+- --charset=UTF-8
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 

data/README.textile

@@ -1,79 +0,0 @@
-h1. Vimeo API Gem
-
-This gem implements a full-featured ruby interface for the Vimeo API.
-
-Vimeo's API documentation is, in my opinion, pretty poor. I've done my best to implement all the functions that are described "here":http://vimeo.com/api-docs/advanced-api-docs.html. There are some extra functions described "here":http://vimeo.com/api/sandbox, but I can't be 100% sure what the correct parameters are for each method, so I'm going to omit them for the time being.
-
-h2. Install
-
-If you haven't already, add github's gem server to your sources:
-
-@gem sources -a http://gems.github.com@
-
-Then, it's as easy as:
-
-@sudo gem install matthooks-vimeo@
-
-Add the gem plugin to your Rails project by adding the following to your @environment.rb@ file:
-
-@config.gem "matthooks-vimeo", :source => "http://gems.github.com/"@
-
-h2. Use
-
-Right now there are two models:
-
-VimeoSimple and VimeoAdvanced
-
-h2. VimeoSimple
-
-VimeoSimple is comprised of class methods:
-
-* VimeoSimple.user_info(username)
-* VimeoSimple.user_clips(username)
-* VimeoSimple.user_likes(username)
-* VimeoSimple.user_appears_in(username)
-* VimeoSimple.user_all_clips(username)
-* VimeoSimple.user_subscriptions(username)
-* VimeoSimple.user_albums(username)
-* VimeoSimple.user_channels(username)
-* VimeoSimple.user_groups(username)
-* VimeoSimple.user_contacts_clips(username)
-* VimeoSimple.user_contacts_like(username)
-* VimeoSimple.clip_info(video_id)
-* VimeoSimple.activity_user_did(username)
-* VimeoSimple.activity_happened_to_user(username)
-* VimeoSimple.activity_contacts_did(username)
-* VimeoSimple.activity_happened_to_contacts(username)
-* VimeoSimple.activity_everyone_did(username)
-* VimeoSimple.group_clips(groupname)
-* VimeoSimple.group_users(groupname)
-* VimeoSimple.group_info(groupname)
-* VimeoSimple.channel_clips(channelname)
-* VimeoSimple.channel_info(channelname)
-* VimeoSimple.album_clips(album_id)
-* VimeoSimple.album_info(album_id)
-
-h2. VimeoAdvanced
-
-VimeoAdvanced must be instantiated with an your application's api key and secret:
-
-@v = VimeoAdvanced.new("api_key", "secret")@
-
-Then you can make calls on the instance:
-
-@v.videos_get_list(user_id, options)@
-
-h2. Todo
-
-* Implement options that allow you to specify a format (xml, json, PHP). Right now this is slightly complicated by the fact that Vimeo returns text/html for json and not application/json, so HTTParty can't auto-detect the content-type.
-* Namespaces! Modules! Etc.
-* Better initialize method for the advanced api that takes the auth_token into account.
-* Define a method that returns the correct form URL for uploading videos.
-* video_set_privacy needs the ability to specify users.
-* Some methods are not implemented by vimeo or don't seem to work.
-* Input verification? The alternative is to just let vimeo handle it.
-* May need to escape input in several cases
-* There's PLENTY of room to re-factor as there is a ton of duplication and I started passing inputs differently about halfway through.
-* Tests
-
-h3. Copyright (c) 2008 Matt Hooks. See LICENSE for details.

data/VERSION.yml

@@ -1,4 +0,0 @@
---- 
-:patch: 2
-:major: 0
-:minor: 1

data/lib/vimeo.rb

@@ -1,883 +0,0 @@
-require 'rubygems'
-require 'httparty'
-require 'digest/md5'
-require 'cgi'
-
-class VimeoSimple
-  include HTTParty
-  base_uri 'vimeo.com/api'
-
-  # USER
-  def self.user_info(username)
-    get("/#{username}/info.json")
-  end
-  
-  def self.user_clips(username)
-    get("/#{username}/clips.json")
-  end
-  
-  def self.user_likes(username)
-    get("/#{username}/likes.json")
-  end
-  
-  def self.user_appears_in(username)
-    get("/#{username}/appears_in.json")
-  end
-  
-  def self.user_all_clips(username)
-    get("/#{username}/all_clips.json")
-  end
-  
-  def self.user_subscriptions(username)
-    get("/#{username}/subscriptions.json")
-  end
-  
-  def self.user_albums(username)
-    get("/#{username}/albums.json")
-  end
-  
-  def self.user_channels(username)
-    get("/#{username}/channels.json")
-  end
-  
-  def self.user_groups(username)
-    get("/#{username}/groups.json")
-  end
-  
-  def self.user_contacts_clips(username)
-    get("/#{username}/contacts_clips.json")
-  end
-  
-  def self.user_contacts_like(username)
-    get("/#{username}/contacts_like.json")
-  end
-  
-  # CLIPS
-  def self.clip_info(video_id)
-    get("/clip/#{video_id}.json")
-  end
-  
-  # ACTIVITY
-  def self.activity_user_did(username)
-    get("/activity/#{username}/user_did.json")
-  end
-  
-  def self.activity_happened_to_user(username)
-    get("/activity/#{username}/happened_to_user.json")
-  end
-  
-  def self.activity_contacts_did(username)
-    get("/activity/#{username}/contacts_did.json")
-  end
-  
-  def self.activity_happened_to_contacts(username)
-    get("/activity/#{username}/happened_to_contacts.json")
-  end
-  
-  def self.activity_everyone_did(username)
-    get("/activity/#{username}/everyone_did.json")
-  end
-  
-  # GROUPS
-  def self.group_clips(groupname)
-    get("/group/#{groupname}/clips.json")
-  end
-  
-  def self.group_users(groupname)
-    get("/group/#{groupname}/users.json")
-  end
-  
-  def self.group_info(groupname)
-    get("/group/#{groupname}/info.json")
-  end
-  
-  # CHANNELS
-  def self.channel_clips(channelname)
-    get("/channel/#{channelname}/clips.json")
-  end
-  
-  def self.channel_info(channelname)
-    get("/channel/#{channelname}/info.json")
-  end
-  
-  # ALBUMS
-  def self.album_clips(album_id)
-    get("/album/#{album_id}/clips.json")
-  end
-  
-  def self.album_info(album_id)
-    get("/album/#{album_id}/info.json")
-  end
-  
-end
-
-class VimeoAdvanced
-  include HTTParty
-  base_uri 'vimeo.com'
-
-  def initialize(api_key, secret, format_options={})
-    @auth = { :api_key => api_key }
-    @secret = secret
-    # TODO: implement format_options
-  end
-  
-  # HELPERS
-  def login_link(perms)
-    api_sig = generate_api_sig :perms => perms
-    "http://vimeo.com/services/auth/?api_key=#{@auth[:api_key]}&perms=#{perms}&api_sig=#{api_sig}"
-  end
-  
-  # TODO: Implement a function that returns the correct upload URL
-  
-  def upload_sig(ticket_id, auth_token)
-    sig_options = {
-      :ticket_id => ticket_id,
-      :auth_token => auth_token
-    }
-    
-    generate_api_sig sig_options
-  end
-  
-  # TEST METHODS
-  def test_echo(options={})
-    method = "vimeo.test.echo"
-    options.merge!(:method => method)
-    api_sig = generate_api_sig options
-    options.merge!(:api_sig => api_sig)
-    self.class.post("/api/rest", :query => options)
-  end
-  
-  def test_null(auth_token)
-    method = "vimeo.test.null"
-    api_sig = generate_api_sig :auth_token => auth_token, :method => method
-    self.class.post("/api/rest", :query => {
-      :api_key => @auth[:api_key],
-      :method => method,
-      :auth_token => auth_token,
-      :api_sig => api_sig
-    })
-  end
-
-  def test_login(auth_token)
-    method = "vimeo.test.login"
-    api_sig = generate_api_sig :auth_token => auth_token, :method => method
-    self.class.post("/api/rest", :query => {
-      :api_key => @auth[:api_key],
-      :auth_token => auth_token,
-      :method => method,
-      :api_sig => api_sig
-    })
-  end
-  
-  # AUTHENTICATION
-  def get_token(frob)
-    method = "vimeo.auth.getToken"
-    api_sig = generate_api_sig :frob => frob, :method => method
-    self.class.post("/api/rest", :query => {
-      :api_key => @auth[:api_key],
-      :frob => frob,
-      :method => method,
-      :api_sig => api_sig
-    })
-  end
-  
-  def get_frob
-    method = "vimeo.auth.getFrob"
-    api_sig = generate_api_sig :method => method
-    self.class.post("/api/rest", :query => {
-      :api_key => @auth[:api_key],
-      :method => method,
-      :api_sig => api_sig
-    })
-  end
-  
-  def check_token(auth_token)
-    method = "vimeo.auth.checkToken"
-    api_sig = generate_api_sig :auth_token => auth_token, :method => method
-    self.class.post("/api/rest", :query => {
-      :api_key => @auth[:api_key],
-      :auth_token => auth_token,
-      :method => method,
-      :api_sig => api_sig
-    })
-  end
-  
-  # LISTS OF VIDEOS
-  def videos_get_list(user_id, options={ :page => 1, :per_page => 25, :full_response => 0 })
-    page = options[:page]
-    per_page = options[:per_page]
-    full_response = options[:full_response]
-    method = "vimeo.videos.getList"
-    api_sig = generate_api_sig :user_id => user_id, :page => page, :per_page => per_page, :fullResponse => full_response, :method => method
-    self.class.post("/api/rest", :query => {
-      :api_key => @auth[:api_key],
-      :user_id => user_id,
-      :page => page,
-      :per_page => per_page,
-      :fullResponse => full_response,
-      :method => method,
-      :api_sig => api_sig
-    })
-  end
-  
-  def videos_get_uploaded_list(user_id, options={ :page => 1, :per_page => 25, :full_response => 0, :auth_token => nil })
-    page = options[:page]
-    per_page = options[:per_page]
-    full_response = options[:full_response]
-    auth_token = options[:auth_token]
-    method = "vimeo.videos.getUploadedList"
-    api_sig = generate_api_sig :user_id => user_id, :page => page, :per_page => per_page, :fullResponse => full_response, :auth_token => auth_token, :method => method
-    self.class.post("/api/rest", :query => {
-      :api_key => @auth[:api_key],
-      :user_id => user_id,
-      :page => page,
-      :per_page => per_page,
-      :fullResponse => full_response,
-      :auth_token => auth_token,
-      :method => method,
-      :api_sig => api_sig
-    })
-  end
-  
-  def videos_get_appears_in_list(user_id, options={ :page => 1, :per_page => 25, :full_response => 0, :auth_token => nil })
-    page = options[:page]
-    per_page = options[:per_page]
-    full_response = options[:full_response]
-    auth_token = options[:auth_token]
-    method = "vimeo.videos.getAppearsInList"
-    api_sig = generate_api_sig :user_id => user_id, :page => page, :per_page => per_page, :fullResponse => full_response, :auth_token => auth_token, :method => method
-    self.class.post("/api/rest", :query => {
-      :api_key => @auth[:api_key],
-      :user_id => user_id,
-      :page => page,
-      :per_page => per_page,
-      :fullResponse => full_response,
-      :auth_token => auth_token,
-      :method => method,
-      :api_sig => api_sig
-    })
-  end
-  
-  def videos_get_subscriptions_list(user_id, options={ :page => 1, :per_page => 25, :full_response => 0, :auth_token => nil })
-    page = options[:page]
-    per_page = options[:per_page]
-    full_response = options[:full_response]
-    auth_token = options[:auth_token]
-    method = "vimeo.videos.getSubscriptionsList"
-    api_sig = generate_api_sig :user_id => user_id, :page => page, :per_page => per_page, :fullResponse => full_response, :auth_token => auth_token, :method => method
-    self.class.post("/api/rest", :query => {
-      :api_key => @auth[:api_key],
-      :user_id => user_id,
-      :page => page,
-      :per_page => per_page,
-      :fullResponse => full_response,
-      :auth_token => auth_token,
-      :method => method,
-      :api_sig => api_sig
-    })
-  end
-  
-  def videos_get_list_by_tag(tag, options={ :page => 1, :per_page => 25, :full_response => 0, :auth_token => nil })
-    user_id = options[:user_id]
-    page = options[:page]
-    per_page = options[:per_page]
-    full_response = options[:full_response]
-    auth_token = options[:auth_token]
-    method = "vimeo.videos.getListByTag"
-    
-    sig_options = {
-      :tag => tag,
-      :page => page,
-      :per_page => per_page,
-      :fullResponse => full_response,
-      :auth_token => auth_token,
-      :method => method
-    }
-    sig_options.merge! :user_id => user_id if !user_id.nil?
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  def videos_get_like_list(user_id, options={ :page => 1, :per_page => 25, :full_response => 0, :auth_token => nil })
-    page = options[:page]
-    per_page = options[:per_page]
-    full_response = options[:full_response]
-    auth_token = options[:auth_token]
-    method = "vimeo.videos.getLikeList"
-    
-    sig_options = {
-      :user_id => user_id,
-      :page => page,
-      :per_page => per_page,
-      :fullResponse => full_response,
-      :auth_token => auth_token,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  def videos_get_contacts_list(user_id, options={ :page => 1, :per_page => 25, :full_response => 0, :auth_token => nil })
-    page = options[:page]
-    per_page = options[:per_page]
-    full_response = options[:full_response]
-    auth_token = options[:auth_token]
-    method = "vimeo.videos.getContactsList"
-    
-    sig_options = {
-      :user_id => user_id,
-      :page => page,
-      :per_page => per_page,
-      :fullResponse => full_response,
-      :auth_token => auth_token,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  def videos_get_contacts_like_list(user_id, options={ :page => 1, :per_page => 25, :full_response => 0, :auth_token => nil })
-    page = options[:page]
-    per_page = options[:per_page]
-    full_response = options[:full_response]
-    auth_token = options[:auth_token]
-    method = "vimeo.videos.getContactsLikeList"
-    
-    sig_options = {
-      :user_id => user_id,
-      :page => page,
-      :per_page => per_page,
-      :fullResponse => full_response,
-      :auth_token => auth_token,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  def videos_search(q, options={ :page => 1, :per_page => 25, :full_response => 0, :auth_token => nil })
-    user_id = options[:user_id]
-    contacts_only = options[:contacts_only]
-    page = options[:page]
-    per_page = options[:per_page]
-    full_response = options[:full_response]
-    auth_token = options[:auth_token]
-    method = "vimeo.videos.search"
-    escaped_query = CGI.escape(q)
-    
-    sig_options = {
-      :query => escaped_query,
-      :page => page,
-      :per_page => per_page,
-      :fullResponse => full_response,
-      :auth_token => auth_token,
-      :method => method
-    }
-    sig_options.merge! :user_id => user_id if !user_id.nil?
-    sig_options.merge! :contacts_only => contacts_only if !contacts_only.nil?
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  # DEALING WITH SPECIFIC VIDEOS
-  def video_get_info(video_id, auth_token=nil)
-    method = "vimeo.videos.getInfo"
-    
-    sig_options = {
-      :video_id => video_id,
-      :auth_token => auth_token,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  def video_delete(video_id, auth_token)
-    method = "vimeo.videos.delete"
-    
-    sig_options = {
-      :video_id => video_id,
-      :auth_token => auth_token,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  def video_get_thumbnail_url(video_id, size=100)
-    method = "vimeo.videos.getThumbnailUrl"
-    
-    sig_options = {
-      :video_id => video_id,
-      :size => size,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  def video_set_title(video_id, title, auth_token)
-    method = "vimeo.videos.setTitle"
-    escaped_title = CGI.escape(title)
-    
-    sig_options = {
-      :video_id => video_id,
-      :title => escaped_title,
-      :auth_token => auth_token,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  def video_set_caption(video_id, caption, auth_token)
-    method = "vimeo.videos.setCaption"
-    escaped_caption = CGI.escape(caption)
-    
-    sig_options = {
-      :video_id => video_id,
-      :caption => escaped_caption,
-      :auth_token => auth_token,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  def video_set_favorite(video_id, favorite, auth_token)
-    method = "vimeo.videos.setFavorite"
-    f = favorite ? true : false
-    
-    sig_options = {
-      :video_id => video_id,
-      :favorite => f,
-      :auth_token => auth_token,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  def video_add_tags(video_id, tags, auth_token)
-    method = "vimeo.videos.addTags"
-    
-    sig_options = {
-      :video_id => video_id,
-      :tags => tags,
-      :auth_token => auth_token,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  def video_remove_tag(video_id, tag_id, auth_token)
-    method = "vimeo.videos.removeTag"
-    
-    sig_options = {
-      :video_id => video_id,
-      :tag_id => tag_id,
-      :auth_token => auth_token,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  def video_clear_tags(video_id, auth_token)
-    method = "vimeo.videos.clearTags"
-    
-    sig_options = {
-      :video_id => video_id,
-      :auth_token => auth_token,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  def video_add_cast(video_id, user_id, auth_token, options={})
-    method = "vimeo.videos.addCast"
-    
-    sig_options = {
-      :video_id => video_id,
-      :user_id => user_id,
-      :auth_token => auth_token,
-      :method => method
-    }
-    sig_options.merge! :role => options[:role] unless options[:role].nil?
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  def video_get_cast(video_id, auth_token=nil)
-    method = "vimeo.videos.getCast"
-    
-    sig_options = {
-      :video_id => video_id,
-      :auth_token => auth_token,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  def video_remove_cast(video_id, user_id, auth_token)
-    method = "vimeo.videos.removeCast"
-    
-    sig_options = {
-      :video_id => video_id,
-      :user_id => user_id,
-      :auth_token => auth_token,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  # TODO: Add ability to specify users
-  def video_set_privacy(video_id, privacy, auth_token)
-    method = "vimeo.videos.setPrivacy"
-    
-    sig_options = {
-      :video_id => video_id,
-      :privacy => privacy,
-      :auth_token => auth_token,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  # VIDEO COMMENTS
-  def video_get_comments_list(video_id)
-    method = "vimeo.videos.comments.getList"
-    
-    sig_options = {
-      :video_id => video_id,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  def video_add_comment(video_id, comment_text, auth_token, options={})
-    reply_to_comment_id = options[:reply_to_comment_id]
-    method = "vimeo.videos.comments.addComment"
-
-    sig_options = {
-      :video_id => video_id,
-      :comment_text => comment_text,
-      :auth_token => auth_token,
-      :method => method
-    }
-    sig_options.merge! :reply_to_comment_id => reply_to_comment_id unless reply_to_comment_id.nil?
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  def video_delete_comment(video_id, comment_id, auth_token)
-    method = "vimeo.videos.comments.deleteComment"
-
-    sig_options = {
-      :video_id => video_id,
-      :comment_id => comment_id,
-      :auth_token => auth_token,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  def video_edit_comment(video_id, comment_id, comment_text, auth_token)
-    method = "vimeo.videos.comments.editComment"
-
-    sig_options = {
-      :video_id => video_id,
-      :comment_id => comment_id,
-      :comment_text => comment_text,
-      :auth_token => auth_token,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  # PEOPLE (USERS)
-  def people_find_by_user_name(username)
-    method = "vimeo.people.findByUserName"
-
-    sig_options = {
-      :username => username,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  def people_find_by_email(find_email)
-    method = "vimeo.people.findByEmail"
-
-    sig_options = {
-      :find_email => find_email,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  def people_get_info(user_id)
-    method = "vimeo.people.getInfo"
-
-    sig_options = {
-      :user_id => user_id,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  # TODO: This seems to be returning nil from Vimeo... not implemented?
-  def people_get_portrait_url(user_id, options={})
-    size = options[:size]
-    method = "vimeo.people.getPortraitUrl"
-
-    sig_options = {
-      :user_id => user_id,
-      :method => method
-    }
-    sig_options.merge! :size => size unless size.nil?
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  # TODO: Not working on Vimeo's side
-  def people_add_contact(user_id, auth_token)
-    method = "vimeo.people.addContact"
-
-    sig_options = {
-      :user_id => user_id,
-      :auth_token => auth_token,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  # TODO: Not working on Vimeo's side
-  def people_remove_contact(user_id, auth_token)
-    method = "vimeo.people.removeContact"
-
-    sig_options = {
-      :user_id => user_id,
-      :auth_token => auth_token,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  def people_get_upload_status(user_id, auth_token)
-    method = "vimeo.people.getUploadStatus"
-
-    sig_options = {
-      :user_id => user_id,
-      :auth_token => auth_token,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  # TODO: Verify input for type?
-  def people_add_subscription(user_id, type, auth_token)
-    method = "vimeo.people.addSubscription"
-
-    sig_options = {
-      :user_id => user_id,
-      :type => type,
-      :auth_token => auth_token,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  # TODO: Verify input for type?
-  def people_remove_subscription(user_id, type, auth_token)
-    method = "vimeo.people.removeSubscription"
-
-    sig_options = {
-      :user_id => user_id,
-      :type => type,
-      :auth_token => auth_token,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  # CONTACTS
-  def contacts_get_list(user_id)
-    method = "vimeo.contacts.getList"
-
-    sig_options = {
-      :user_id => user_id,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  # GROUPS
-  # TODO: Only takes group_id as int, not group name
-  def groups_get_members(group_id)
-    method = "vimeo.groups.getMembers"
-
-    sig_options = {
-      :group_id => group_id,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  # UPLOAD
-  def video_get_upload_ticket(auth_token)
-    method = "vimeo.videos.getUploadTicket"
-
-    sig_options = {
-      :auth_token => auth_token,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  def video_check_upload_status(ticket_id, auth_token)
-    method = "vimeo.videos.checkUploadStatus"
-
-    sig_options = {
-      :ticket_id => ticket_id,
-      :auth_token => auth_token,
-      :method => method
-    }
-    
-    api_sig = generate_api_sig sig_options
-    query = sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
-    
-    self.class.post("/api/rest", :query => query)
-  end
-  
-  private
-  
-    # Keys must be sorted alphabetically
-    def generate_api_sig(options={})
-      options.merge! @auth
-      api_sig = options.sort { |a, b| a.to_s <=> b.to_s }.join
-      Digest::MD5.hexdigest("#{@secret}#{api_sig}")
-    end
-  
-end

data/test/test_helper.rb

@@ -1,7 +0,0 @@
-require 'rubygems'
-require 'test/unit'
-require 'shoulda'
-require 'mocha'
-
-class Test::Unit::TestCase
-end

data/test/vimeo_test.rb

@@ -1,7 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-class VimeoTest < Test::Unit::TestCase
-  should "probably rename this file and start testing for real" do
-    flunk "hey buddy, you should probably rename this file and start testing for real"
-  end
-end