vimeo 1.0.0

data/.gitignore

@@ -0,0 +1,3 @@
+*.sw?
+.DS_Store
+coverage

data/CHANGELOG.rdoc

@@ -0,0 +1,24 @@
+== 1.0.0, released 2009-09-28
+
+* Upgraded to v2 of the API.
+* Added some upload helpers.
+* Huge refactor for the Advanced API making it easier to add/modify method calls.
+
+== 0.2.2, released 2009-04-21
+
+* Removed CGI escapes. Vimeo should be handling them on their end.
+
+== 0.2.1, released 2009-01-06
+
+* Last version was missing files.
+
+== 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) 2009 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,322 @@
+= Vimeo API Gem
+
+This gem implements a full-featured Ruby interface for the Vimeo API v2.
+
+For a more in depth look at the API check out {Vimeo's Simple API Documentation}[http://www.vimeo.com/api/docs/simple-api] or {Vimeo's Advanced API Documentation}[http://www.vimeo.com/api/docs/advanced-api]. I would also recommend checking out the {API Forums}[http://www.vimeo.com/forum:api] if
+things aren't working as they should -- in my experience the Vimeo API has a number of bugs and oddities.
+
+== 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}[http://www.vimeo.com/api/docs/simple-api] consists of several classes. To use the Simple API, just call one of the class methods. For example:
+
+  user_info = Vimeo::Simple::User.info("matthooks")
+  # =>
+  # {
+  #   "id":"888046",
+  #   "display_name":"Matt Hooks",
+  #   "created_on":"2008-10-30 14:17:32",
+  #   "is_staff":"0",
+  #   "is_plus":"0",
+  #   "location":"Chicago, IL",
+  #   "url":"http:\/\/blackholeinthemidwest.com\/",
+  #   "bio":"",
+  #   "profile_url":"http:\/\/vimeo.com\/matthooks",
+  #   "videos_url":"http:\/\/vimeo.com\/matthooks\/videos",
+  #   "total_videos_uploaded":2,
+  #   "total_videos_appears_in":0,
+  #   "total_videos_liked":2,
+  #   "total_contacts":3,
+  #   "total_albums":0,
+  #   "total_channels":1,
+  #   "portrait_small":"http:\/\/images.vimeo.com\/11\/42\/16\/114216178\/114216178_30.jpg",
+  #   "portrait_medium":"http:\/\/images.vimeo.com\/11\/42\/16\/114216178\/114216178_75.jpg",
+  #   "portrait_large":"http:\/\/images.vimeo.com\/11\/42\/16\/114216178\/114216178_100.jpg",
+  #   "portrait_huge":"http:\/\/images.vimeo.com\/11\/42\/16\/114216178\/114216178_300.jpg"
+  # }
+
+  # That's right! The data returned will be parsed and ready to use.
+
+  user_info["location"]
+  # => "Chicago, IL"
+
+=== 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::Album
+
+  Vimeo::Simple::Album.videos("album_id")
+  Vimeo::Simple::Album.info("album_id")
+  
+=== Vimeo::Simple::Channel
+
+  Vimeo::Simple::Channel.videos(channelname)
+  Vimeo::Simple::Channel.info(channelname)
+
+=== Vimeo::Simple::Group
+
+  Vimeo::Simple::Group.videos(groupname)
+  Vimeo::Simple::Group.users(groupname)
+  Vimeo::Simple::Group.info(groupname)
+
+=== Vimeo::Simple::User
+
+  Vimeo::Simple::User.info(username)
+  Vimeo::Simple::User.videos(username)
+  Vimeo::Simple::User.likes(username)
+  Vimeo::Simple::User.appears_in(username)
+  Vimeo::Simple::User.all_videos(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_videos(username)
+  Vimeo::Simple::User.contacts_like(username)
+
+=== Vimeo::Simple::Video
+
+  Vimeo::Simple::Video.info(video_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 method calls on the instance. For example:
+
+  vimeo_video.get_list("matthooks", :page => 2, :per_page => 50)
+  
+Some methods have optional variables. You should pass as a hash at the end of a call.
+
+Some methods require authentication. Check out the guides for {Web Based authentication}[http://www.vimeo.com/api/docs/web-auth] and {Desktop Based authentication}[http://www.vimeo.com/api/docs/desktop-auth].
+
+The wrapper for the Advanced API consists of the following classes and methods:
+
+=== Vimeo::Advanced::Album
+
+  album = Vimeo::Advanced::Album.new("api_key", "secret")
+  
+  album.add_video("auth_token", "album_id", "video_id")
+  album.create("auth_token", "title", "video_id", { :description => "description", "videos" => "123,124,125" })
+  album.delete("auth_token", "album_id")
+  album.get_all("user_id", { :page => "1", :per_page => "25" })
+  album.get_videos("auth_token", "user_id", { :page => "1", :per_page => "25", :full_response => "0", :password => nil })
+  album.get_videos("auth_token", "album_id", "video_id")
+  album.set_description("auth_token", "album_id", "description")
+  album.get_password("auth_token", "album_id", "password")
+  album.get_title("auth_token", "album_id", "title")
+
+=== Vimeo::Advanced::Auth
+
+  auth = Vimeo::Advanced::Auth.new("api_key", "secret")
+
+  auth.get_token("frob")
+  auth.get_frob
+  auth.check_token("auth_token")
+  
+=== Vimeo::Advanced::Base
+
+  base = Vimeo::Advanced::Base.new("api_key", "secret")
+
+  base.web_login_link("permissions")
+  base.desktop_login_link("permissions")
+  
+=== Vimeo::Advanced::Channel
+
+  channel = Vimeo::Advanced::Channel.new("api_key", "secret")
+  
+  channel.add_video("auth_token", "channel_id", "video_id")
+  channel.get_all({ :page => "1", :per_page => "25", :sort => "newest"})
+  channel.get_info(channel_id, { :page => "1", :per_page => "25" })
+  channel.get_moderators(channel_id, { :page => "1", :per_page => "25" })
+  channel.get_subscribers(channel_id, { :page => "1", :per_page => "25" })
+  channel.get_videos(channel_id, { :page => "1", :per_page => "25", :full_response => "0" })
+  channel.remove_video("auth_token", "channel_id", "video_id")
+  channel.subscribe("auth_token", "channel_id")
+  channel.unsubscribe("auth_token", "channel_id")
+
+=== Vimeo::Advanced::Contact
+
+  contact = Vimeo::Advanced::Contact.new("api_key", "secret")
+
+  contact.get_all(user_id, { :page => "1", :per_page => "25", :sort => "newest" })
+  contact.get_mutual(user_id, { :page => "1", :per_page => "25", :sort => "newest" })
+  contact.get_online({ :page => "1", :per_page => "25", :sort => "newest" })
+  contact.get_who_added(user_id, { :page => "1", :per_page => "25", :sort => "newest" })
+
+=== Vimeo::Advanced::Group
+
+  group = Vimeo::Advanced::Group.new("api_key", "secret")
+
+  group.add_video("auth_token", "group_id", "video_id")
+  group.get_all({ :page => "1", :per_page => "25", :sort => "newest" })
+  group.get_files("group_id", { :page => "1", :per_page => "25" })
+  group.get_info("group_id", { :page => "1", :per_page => "25" })
+  group.get_members("group_id", { :page => "1", :per_page => "25", :sort => "newest" })
+  group.get_moderators("group_id", { :page => "1", :per_page => "25" })
+  group.get_video_comments("group_id", "video_id", { :page => "1", :per_page => "25" })
+  group.get_videos("group_id", { :page => "1", :per_page => "25", :full_response => "0", :sort => "newest" })
+  group.join("auth_token", "group_id")
+  group.leave("auth_token", "group_id")
+
+=== Vimeo::Advanced::GroupEvents
+
+  group_events = Vimeo::Advanced::GroupEvents.new("api_key", "secret")
+
+  group_events.get_month("group_id", { :page => "1", :per_page => "25", :month => nil, :year => nil })
+  group_events.get_past("group_id", { :page => "1", :per_page => "25" })
+  group_events.get_year("group_id", { :page => "1", :per_page => "25" })
+
+=== Vimeo::Advanced::GroupForums
+
+  group_forums = Vimeo::Advanced::GroupForums.new("api_key", "secret")
+
+  group_forums.get_topic_comments("group_id", "topic_id", { :page => "1", :per_page => "25" })
+  group_forums.get_topics("group_id", { :page => "1", :per_page => "25" })
+
+=== Vimeo::Advanced::Person
+
+  person = Vimeo::Advanced::Person.new("api_key", "secret")
+
+  person.add_contact("auth_token", "user_id")
+  # Types is a comma-delimited string. Valid options: "likes", "appears", "uploads"
+  person.add_subscription("auth_token", "user_id", "types")
+  person.find_by_email("user_id")
+  person.get_hd_embeds("auth_token")
+  person.get_info("user_id")
+  person.get_portrait_urls("user_id")
+  person.remove_contact("auth_token", "user_id")
+  # Types is a comma-delimited string. Valid options: "likes", "appears", "uploads"
+  person.remove_subscription("auth_token", "user_id", "types")
+
+=== Vimeo::Advanced::Test
+
+  test = Vimeo::Advanced::Test.new("api_key", "secret")
+
+  test.echo(options={})
+  test.null(auth_token)
+  test.login(auth_token)
+
+=== Vimeo::Advanced::Upload
+
+  upload = Vimeo::Advanced::Upload.new("api_key", "secret")
+  
+  upload.confirm("auth_token", "ticket_id", "json_manifest")
+  upload.get_quota("auth_token")
+  upload.get_ticket("auth_token")
+  upload.upload("auth_token", "path_to_file", "ticket_id", "end_point")
+  upload.verify_manifest("auth_token", "ticket_id", "json_manifest")
+
+=== Vimeo::Advanced::Video
+
+  video = Vimeo::Advanced::Video.new("api_key", "secret")
+
+  video.add_cast("auth_token", "video_id", "user_id", { :role => nil })
+  video.add_photos("auth_token", "video_id", "photo_urls")
+  video.add_tags("auth_token", "video_id", "tags")
+  video.clear_tags("auth_token", "video_id")
+  video.delete("auth_token", "video_id")
+  video.get_all("user_id", { :page => "1", :per_page => "25", :full_response => "0", :sort => "newest" })
+  video.get_appears_in("user_id", { :page => "1", :per_page => "25", :full_response => "0", :sort => "newest" })
+  video.get_by_tag("tag", { :page => "1", :per_page => "25", :full_response => "0", :sort => "newest" })
+  video.get_cast("video_id", { :page => "1", :per_page => "25" })
+  video.get_contacts_liked("user_id", { :page => "1", :per_page => "25", :full_response => "0", :sort => "newest" })
+  video.get_contacts_uploaded("user_id", { :page => "1", :per_page => "25", :full_response => "0", :sort => "newest" })
+  video.get_info("video_id")
+  video.get_likes("user_id", { :page => "1", :per_page => "25", :full_response => "0", :sort => "newest" })
+  video.get_subscriptions("user_id", { :page => "1", :per_page => "25", :full_response => "0", :sort => "newest" })
+  video.get_thumbnail_urls("video_id")
+  video.get_uploaded("user_id", { :page => "1", :per_page => "25", :full_response => "0", :sort => "newest" })
+  video.remove_cast("auth_token", "video_id", "user_id")
+  video.remove_tag("auth_token", "video_id", "tag_id")
+  video.search("query", { :page => "1", :per_page => "25", :full_response => "0", :sort => "newest", :user_id => nil })
+  video.set_description("auth_token", "video_id", "description")
+  video.set_like("auth_token", "video_id", "like")
+  video.set_privacy("auth_token", "video_id", "privacy", { :users => nil, :password => nil })
+  video.set_title("auth_token", "video_id", "title")
+
+  # comments
+  video.add_comment("auth_token", "video_id", "comment_text", { :reply_to_comment_id => nil })
+  video.delete_comment("auth_token", "video_id", "comment_id")
+  video.edit_comment("auth_token", "video_id", "comment_id", "comment_text")
+  video.get_comments_list("video_id", { :page => "1", :per_page => "25" })
+                  
+=== Vimeo::Advanced::VideoEmbed
+
+  video_embed = Vimeo::Advanced::VideoEmbed.new("api_key", "secret")
+
+  video_embed.get_presets("auth_token", { :page => "1", :per_page => "25" })
+  video_embed.set_preset("auth_token", "video_id", "preset_id")
+
+
+== Uploads
+
+Uploads are a little bit tricky, so I figured I'd help you guys with a short tutorial.
+
+  # Start by creating an instance of the Upload class.
+  upload = Vimeo::Advanced::Upload.new("api_key", "secret")
+  # I'm going to assume you've got that user's auth token stored somewhere and that they have upload access.
+  auth_token = "..."
+  
+  # Let's check the user's quota.
+  # You should let the user know if they don't have enough quota free and/or if their video can be uploaded in HD
+  quota = upload.get_quota(auth_token)
+  free_space = quota["user"]["upload_space"]["free"]
+  hd = quota["user"]["hq_quota"]
+  
+  # Now let's get an upload ticket.
+  ticket = upload.get_ticket(auth_token)
+  ticket_id = get_ticket["ticket"]["id"]
+  endpoint = get_ticket["ticket"]["endpoint"]
+
+  # Cool! Let's post the video.
+  # The file path should be absolute.
+  file_path = "..."
+  json_manifest = upload.upload(auth_token, file_path, ticket_id, endpoint)
+  
+  # After the upload completes...
+  upload.confirm(auth_token, ticket_id, json_manifest)
+  
+There are a few steps along the way where things can go wrong.
+
+== Todo
+
+* Better structure. There's too many classes. Is there a way to simplify the Advanced API?
+* Advanced classes should be able to take the authentication token as a parameter so you don't have to pass it to the methods that require authentication.
+* Error handling.
+* Some methods are not implemented by Vimeo or don't seem to work.
+* More re-factoring.
+* Make tests more robust and faster. If anyone has any ideas let me know.
+
+== 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.

data/Rakefile

@@ -0,0 +1,68 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "vimeo"
+    gem.summary = %Q{A full featured Ruby implementation of the Vimeo API.}
+    gem.description = %Q{A full featured Ruby implementation of the Vimeo API.}
+    gem.email = "matthooks@gmail.com"
+    gem.homepage = "http://github.com/matthooks/vimeo"
+    gem.authors = ["Matt Hooks"]
+    gem.rubyforge_project = "vimeo"
+    gem.add_development_dependency "thoughtbot-shoulda", ">= 2.10.2"
+    gem.add_development_dependency "fakeweb", ">= 1.2.6"
+    gem.add_development_dependency "crack", ">= 0.1.4"
+    
+    gem.has_rdoc = true
+    
+    gem.rdoc_options = ['--main', 'README.rdoc', '--inline-source', '--charset=UTF-8']
+    gem.extra_rdoc_files = ['README.rdoc', 'LICENSE', 'CHANGELOG.rdoc']
+    
+    gem.add_dependency "httparty", ">= 0.4.5"
+    gem.add_dependency "curb", ">= 0.5.4.0"
+    gem.add_dependency "json", ">= 1.1.9"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "vimeo #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION.yml

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

data/lib/vimeo/advanced/album.rb

@@ -0,0 +1,57 @@
+module Vimeo
+  module Advanced
+    class Album < Vimeo::Advanced::Base
+
+      # Adds a video to an album.
+      create_api_method :add_video,
+                        "vimeo.albums.addVideo",
+                        :required => [:auth_token, :album_id, :video_id]
+
+      # Creates an album.
+      # FIXME: Nothing is returned if you add multiple videos to an album.
+      # The optional parameter videos is a comma-separated list of video ids.
+      create_api_method :create,
+                        "vimeo.albums.create",
+                        :required => [:auth_token, :title, :video_id],
+                        :optional => [:description, :videos]
+      
+      # Deletes an album.
+      create_api_method :delete,
+                        "vimeo.albums.delete",
+                        :required => [:auth_token, :album_id]
+      
+      # Returns a list of a user's albums.
+      create_api_method :get_all,
+                        "vimeo.albums.getAll",
+                        :required => [:user_id],
+                        :optional => [:page, :per_page, :sort]
+      
+      # Returns a list of the videos in an album.
+      create_api_method :get_videos,
+                        "vimeo.albums.getVideos",
+                        :required => [:auth_token, :album_id],
+                        :optional => [:page, :per_page, :full_response, :password]
+      
+      # Removes a video from an album.
+      create_api_method :remove_video,
+                        "vimeo.albums.removeVideo",
+                        :required => [:auth_token, :album_id, :video_id]
+
+      # Sets the description of an album.
+      create_api_method :set_description,
+                        "vimeo.albums.setDescription",
+                        :required => [:auth_token, :album_id, :description]
+                        
+      # Sets the password of an album.
+      create_api_method :set_password,
+                        "vimeo.albums.setPassword",
+                        :required => [:auth_token, :album_id, :password]
+      
+      # Sets the title of an album.
+      create_api_method :set_title,
+                        "vimeo.albums.setTitle",
+                        :required => [:auth_token, :album_id, :title]
+
+    end # Album
+  end # Advanced
+end # Vimeo

data/lib/vimeo/advanced/auth.rb

@@ -0,0 +1,22 @@
+module Vimeo
+  module Advanced
+    class Auth < Vimeo::Advanced::Base
+      
+      # Tests the validity of an authorization token.
+      create_api_method :check_token,
+                        "vimeo.auth.checkToken",
+                        :required => [:auth_token]
+
+      # Obtains a frob.
+      # Used for desktop based authentication.
+      create_api_method :get_frob,
+                        "vimeo.auth.getFrob"
+
+      # Obtains an authorization token.
+      create_api_method :get_token,
+                        "vimeo.auth.getToken",
+                        :required => [:frob]
+
+    end
+  end # Advanced
+end # Vimeo

data/lib/vimeo/advanced/base.rb

@@ -0,0 +1,105 @@
+module CreateApiMethod
+  
+  # Small DSL that creates a method that calls a Vimeo method through the advanced API.
+  #
+  # @param [String] method The name of the method being created.
+  # @param [String] vimeo_method The name of the advanced API Method the function should call.
+  # @param [Hash] options Some optional parameters.
+  # @option options [Array] :required An array of required parameters.
+  # @option options [Array] :optional An array of optional parameters.
+  # @option options [Array] :unsigned An array of required parameters that should not be included in the api_sig.
+  def create_api_method(method, vimeo_method, options={})
+    options = { :required => [], :optional => [], :unsigned => [] }.merge(options)
+    
+    raise ArgumentError, 'Required parameters must be an array.' unless options[:required].is_a? Array
+    raise ArgumentError, 'Optional parameters must be an array.' unless options[:optional].is_a? Array
+    raise ArgumentError, 'Unsigned parameters must be an array.' unless options[:optional].is_a? Array
+    
+    required = (options[:required] + options[:unsigned]).map { |r| r.to_s }.join(",")
+    required_hash = options[:required].map { |r| ":#{r} => #{r}" }.join(",")
+    optional_hash = options[:optional].map { |o| ":#{o} => nil" }.join(",")
+    unsigned_hash = options[:unsigned].map { |u| ":#{u} => #{u}" }.join(",")
+    
+    parameters = "(#{required unless required.blank?}#{',' unless required.blank?}options={#{optional_hash}})"
+    
+    method_string = <<-method
+
+      def #{method}#{parameters}
+        raise ArgumentError, 'Options must be a hash.' unless options.is_a? Hash
+        
+        sig_options = {
+          :method => "#{vimeo_method}",
+          :format => "json"
+        }
+
+        #{ options[:required].map { |r| "sig_options.merge! :#{r} => #{r}"}.join("\n") }
+        #{ options[:optional].map { |o| "sig_options.merge! :#{o} => options[:#{o}] unless options[:#{o}].nil?" }.join("\n") }
+        
+        make_request sig_options#{ ", :unsigned => {" + unsigned_hash + "}" unless options[:unsigned].empty? }
+      end
+      
+    method
+    
+    class_eval method_string
+  end
+
+end
+
+module Vimeo
+  module Advanced
+
+    class Base
+      include HTTParty
+      base_uri 'vimeo.com'
+      extend CreateApiMethod
+
+      # TODO: Pass an auth token, if you've already got one
+      # TODO: implement format_options
+      # Requires your API key and secret phrase.
+      # The API key and secret are prepended to every request.
+      def initialize(api_key, secret, format_options={})
+        @auth = { :api_key => api_key }
+        @secret = secret
+      end
+      
+      # Generates a link that allows a user to authorize
+      # your web application to use the advanced API
+      def web_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
+      
+      # Generates a link that allows a user to authorize
+      # your desktop application to use the advanced API
+      def desktop_login_link(perms, frob)
+        api_sig = generate_api_sig :frob => frob, :perms => perms
+        "http://vimeo.com/services/auth/?api_key=#{@auth[:api_key]}&perms=#{perms}&frob=#{frob}&api_sig=#{api_sig}"
+      end
+      
+      private
+
+      def make_request(sig_options, options={})
+        options = { :unsigned => [] }.merge(options)
+        unsigned = options[:unsigned]
+
+        api_sig = generate_api_sig sig_options
+        self.class.post "/api/rest/v2", :query => query(sig_options, api_sig), :body => unsigned
+      end
+
+      # Generates a MD5 hashed API signature for Advanced API requests
+      def generate_api_sig(options={})
+        # Every request requires the api_key parameter
+        options.merge! @auth
+        # Keys must be sorted alphabetically
+        api_sig = options.sort { |a, b| a.to_s <=> b.to_s }.join
+        Digest::MD5.hexdigest("#{@secret}#{api_sig}")
+      end
+      
+      def query(sig_options, api_sig)
+        sig_options.merge :api_key => @auth[:api_key], :api_sig => api_sig
+      end
+
+    end # Base
+
+  end # Advanced
+end # Vimeo