slainer68_vimeo 1.4.3

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.markdown

@@ -0,0 +1,330 @@
+# 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.
+
+## Install
+
+First, install [Gemcutter](http://gemcutter.org), then:
+
+    sudo gem install vimeo
+
+If you're using Rails, add the following to your environment.rb file:
+
+    config.gem "vimeo"
+
+Or for bundler:
+
+gem 'vimeo'
+
+## How to Use
+
+There are two modules:
+
+    Vimeo::Simple
+    Vimeo::Advanced
+
+## Simple API
+
+Let's look at the [Simple API](http://www.vimeo.com/api/docs/simple-api) first.
+
+The wrapper for the 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_appears_ined":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"
+    # }
+
+Thanks to HTTParty, the data is parsed and ready to use.
+
+    user_info["location"]
+    # => "Chicago, IL"
+
+## Overview of the Simple API
+
+### 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
+
+To use the [Advanced API](http://www.vimeo.com/api/docs/advanced-api), first you must authenticate your user using OAuth.
+
+### Authentication Example using Rails
+
+First, instantiate the Base class:
+
+    base = Vimeo::Advanced::Base.new("consumer_key", "consumer_secret")
+
+Get a request token, and save the token secret in the session hash.
+
+    request_token = base.get_request_token
+    session[:oauth_secret] = request_token.secret
+
+Then, send your user to the authorization URL:
+
+    redirect_to base.authorize_url
+
+Once the user has allowed your application to access their account, they will be redirected to the callback URL you set up for your application. You will be given two parameters `oauth_token` and `oauth_verifier`. Re-instantiate your Base class, then get an access token.
+
+    base = Vimeo::Advanced::Base.new("consumer_key", "consumer_secret")
+    access_token = base.get_access_token(params[:oauth_token], session[:oauth_secret], params[:oauth_verifier])
+    # You'll want to hold on to the user's access token and secret. I'll save it to the database.
+    user.token = access_token.token
+    user.secret = access_token.secret
+    user.save
+
+Now you've got everything you need to use the Advanced API. Let's get a user's videos:
+
+    video = Vimeo::Advanced::Video.new("consumer_key", "consumer_secret", :token => user.token, :secret => user.secret)
+    video.get_videos("matthooks")
+
+    # => {"videos"=> { ... }, "stat"=>"ok", "generated_in"=>"0.5753"}
+
+Piece of cake.
+
+Some methods have optional variables. Pass these as a hash at the end of a call.
+
+    video.get_all("matthooks", :page => "2", :per_page => "50")
+
+## Overview of the Advanced API
+
+### Vimeo::Advanced::Album
+
+    album = Vimeo::Advanced::Album.new("consumer_key", "consumer_secret", :token => user.token, :secret => user.secret)
+
+    album.add_video("album_id", "video_id")
+    album.create("title", "video_id", { :description => "description", "videos" => "123,124,125" })
+    album.delete("album_id")
+    album.get_all("user_id", { :page => "1", :per_page => "25", :sort => "newest" })
+    album.get_videos("album_id", { :page => "1", :per_page => "25", :full_response => "0", :password => nil })
+    album.remove_video("album_id", "video_id")
+    album.set_description("album_id", "description")
+    album.get_password("album_id", "password")
+    album.get_title("album_id", "title")
+
+### Vimeo::Advanced::Base
+
+    base = Vimeo::Advanced::Base.new("consumer_key", "consumer_secret", :token => user.token, :secret => user.secret)
+
+    base.check_access_token
+
+### Vimeo::Advanced::Channel
+
+    channel = Vimeo::Advanced::Channel.new("consumer_key", "consumer_secret", :token => user.token, :secret => user.secret)
+
+    channel.add_video("channel_id", "video_id")
+    channel.get_all({ :page => "1", :per_page => "25", :sort => "newest", :user_id => "user_id" })
+    channel.get_info(channel_id)
+    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("channel_id", "video_id")
+    channel.subscribe("channel_id")
+    channel.unsubscribe("channel_id")
+
+### Vimeo::Advanced::Contact
+
+    contact = Vimeo::Advanced::Contact.new("consumer_key", "consumer_secret", :token => user.token, :secret => user.secret)
+
+    contact.get_all(user_id, { :page => "1", :per_page => "25", :sort => "newest" })
+    contact.get_mutual(user_id, { :page => "1", :per_page => "25" })
+    contact.get_online({ :page => "1", :per_page => "25" })
+    contact.get_who_added(user_id, { :page => "1", :per_page => "25", :sort => "newest" })
+
+### Vimeo::Advanced::Group
+
+    group = Vimeo::Advanced::Group.new("consumer_key", "consumer_secret", :token => user.token, :secret => user.secret)
+
+    group.add_video("group_id", "video_id")
+    group.get_all({ :page => "1", :per_page => "25", :sort => "newest", :user_id => "user_id" })
+    group.get_files("group_id", { :page => "1", :per_page => "25" })
+    group.get_info("group_id")
+    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("group_id")
+    group.leave("group_id")
+
+### Vimeo::Advanced::GroupEvents
+
+    group_events = Vimeo::Advanced::GroupEvents.new("consumer_key", "consumer_secret", :token => user.token, :secret => user.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("consumer_key", "consumer_secret", :token => user.token, :secret => user.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("consumer_key", "consumer_secret", :token => user.token, :secret => user.secret)
+
+    person.add_contact("user_id")
+    person.add_subscription("user_id", "types") # Types is a comma-delimited string. Valid: "likes", "appears", "uploads"
+    person.find_by_email("user_id")
+    person.get_hd_embeds
+    person.get_info("user_id")
+    person.get_portrait_urls("user_id")
+    person.remove_contact("user_id")
+    person.remove_subscription("user_id", "types") # Types is a comma-delimited string. Valid: "likes", "appears", "uploads"
+
+### Vimeo::Advanced::Test
+
+    test = Vimeo::Advanced::Test.new("consumer_key", "consumer_secret", :token => user.token, :secret => user.secret)
+
+    test.echo
+    test.null
+    test.login
+
+### Vimeo::Advanced::Upload
+
+    upload = Vimeo::Advanced::Upload.new("consumer_key", "consumer_secret", :token => user.token, :secret => user.secret)
+
+    # Other than get_quota, none of these methods should be called directly. The 'upload' method uses these internally.
+    upload.check_ticket("ticket_id")
+    upload.complete("ticket_id", "filename")
+    upload.get_ticket
+    upload.get_quota
+    upload.verify_chunks("ticket_id")
+
+    # all-in-one solution, supports File, String (a file path), #read
+    video_id = upload.upload("movie.mp4")
+
+### Vimeo::Advanced::Video
+
+    video = Vimeo::Advanced::Video.new("consumer_key", "consumer_secret", :token => user.token, :secret => user.secret)
+
+    video.add_cast("video_id", "user_id", { :role => nil })
+    video.add_photos("video_id", "photo_urls")
+    video.add_tags("video_id", "tags")
+    video.clear_tags("video_id")
+    video.delete("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("video_id", "user_id")
+    video.remove_tag("video_id", "tag_id")
+    video.search("query", { :page => "1", :per_page => "25", :full_response => "0", :sort => "newest", :user_id => nil })
+    video.set_description("video_id", "description")
+    video.set_like("video_id", "like")
+    video.set_privacy("video_id", "privacy", { :users => nil, :password => nil })
+    video.set_title("video_id", "title")
+
+    # comments
+    video.add_comment("video_id", "comment_text", { :reply_to_comment_id => nil })
+    video.delete_comment("video_id", "comment_id")
+    video.edit_comment("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("consumer_key", "consumer_secret", :token => user.token, :secret => user.secret)
+
+    video_embed.get_presets({ :page => "1", :per_page => "25" })
+    video_embed.set_preset("video_id", "preset_id")
+
+## Uploads
+
+Uploads are working! In order to upload a file, create your upload object, like so:
+
+    upload = Vimeo::Advanced::Upload.new("consumer_key", "consumer_secret", :token => user.token, :secret => user.secret)
+
+Then call the upload method:
+
+    upload.upload("/path/to/file") # You can also pass a File object or any IO.
+
+The upload method will automatically get an upload ticket, perform the multipart POST, verify the file chunks and then complete the upload.
+
+## Todo
+
+* Fix tests that cannot be stubbed because of OAuth nonce.
+* Better structure. There's too many classes. Is there a way to simplify the Advanced API?
+* Better error handling.
+* More re-factoring.
+* Make tests more robust and faster. If anyone has any ideas let me know.
+
+## Contributors
+
+* [matthooks](http://github.com/matthooks)
+* [sirlantis](http://github.com/sirlantis)
+
+## Thanks to
+
+* [HTTParty](http://github.com/jnunemaker/httparty): Easily one of the best tools I have used since I started using Ruby.
+* [Jeweler](http://github.com/technicalpickles/jeweler): Great tool for creating gems for Github.
+
+### Copyright (c) 2009-2010 Matt Hooks. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,100 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "slainer68_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 "shoulda", ">= 2.11.3"
+    gem.add_development_dependency "fakeweb", ">= 1.2.6"
+    gem.add_development_dependency "ruby-prof", ">= 0.9.2"
+
+    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 "multi_json", ">= 1.0.4"
+    gem.add_dependency "httparty", ">= 0.4.5"
+    gem.add_dependency "oauth", ">= 0.4.3"
+    gem.add_dependency "httpclient", ">= 2.1.5.2"
+    gem.add_dependency "multipart-post", ">= 1.0.1"
+  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
+
+namespace :vimeo do
+  desc "Multi-step wizard to acquire an access_token. CONSUMER_KEY and CONSUMER_SECRET required."
+  task :auth do
+    require 'vimeo'
+
+    def ask(message)
+      print message
+      STDOUT.flush
+      STDIN.gets.chomp
+    end
+
+    consumer_key = ENV['CONSUMER_KEY']
+    consumer_secret = ENV['CONSUMER_SECRET']
+    base = Vimeo::Advanced::Base.new(consumer_key, consumer_secret)
+
+    request_token = base.get_request_token
+    oauth_secret = request_token.secret
+
+    puts "Please visit: #{base.authorize_url}"
+
+    oauth_token = ask("oauth_token=")
+    oauth_verifier = ask("oauth_verifier=")
+
+    access_token = base.get_access_token(oauth_token, oauth_secret, oauth_verifier)
+
+    puts "token: #{access_token.token}"
+    puts "secret: #{access_token.secret}"
+  end
+end
+
+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,5 @@
+---
+:major: 1
+:minor: 4
+:patch: 3
+:build: !!null 

data/init.rb

@@ -0,0 +1,2 @@
+$:.unshift(File.dirname(__FILE__))
+require 'lib/vimeo'

data/lib/vimeo/advanced/album.rb

@@ -0,0 +1,55 @@
+module Vimeo
+  module Advanced
+    class Album < Vimeo::Advanced::Base
+
+      # Adds a video to an album.
+      create_api_method :add_video,
+                        "vimeo.albums.addVideo",
+                        :required => [:album_id, :video_id]
+
+      # Creates an album.
+      create_api_method :create,
+                        "vimeo.albums.create",
+                        :required => [:title, :video_id],
+                        :optional => [:description, :videos]
+      
+      # Deletes an album.
+      create_api_method :delete,
+                        "vimeo.albums.delete",
+                        :required => [: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 => [:album_id],
+                        :optional => [:page, :per_page, :full_response, :password]
+      
+      # Removes a video from an album.
+      create_api_method :remove_video,
+                        "vimeo.albums.removeVideo",
+                        :required => [:album_id, :video_id]
+
+      # Sets the description of an album.
+      create_api_method :set_description,
+                        "vimeo.albums.setDescription",
+                        :required => [:album_id, :description]
+                        
+      # Sets the password of an album.
+      create_api_method :set_password,
+                        "vimeo.albums.setPassword",
+                        :required => [:album_id, :password]
+      
+      # Sets the title of an album.
+      create_api_method :set_title,
+                        "vimeo.albums.setTitle",
+                        :required => [:album_id, :title]
+
+    end # Album
+  end # Advanced
+end # Vimeo

data/lib/vimeo/advanced/base.rb

@@ -0,0 +1,126 @@
+require 'oauth'
+
+module CreateApiMethod
+  
+  # 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.
+  def create_api_method(method, vimeo_method, options={})
+    options = { :required => [], :optional => [] }.merge(options)
+    
+    method = method.to_s
+    camelized_method = camelize(method, false)
+    
+    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
+    
+    required = options[:required].map { |r| r.to_s }.join(",")
+    optional = options[:optional].map { |o| ":#{o} => nil" }.join(",")
+    authorized = options.fetch(:authorized, true)
+    
+    parameters = "(#{required unless required.empty?}#{',' unless required.empty?}options={#{optional}})"
+    
+    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, #{authorized ? "true" : "false"}
+      end
+      
+      alias #{camelized_method} #{method}
+      
+    method
+    
+    class_eval method_string
+  end
+  
+  protected
+  
+  # taken from ActiveSupport-2.3.4, activesupport/lib/active_support/inflector.rb, line 178
+  def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+    if first_letter_in_uppercase
+      lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    else
+      lower_case_and_underscored_word[0..0].downcase + camelize(lower_case_and_underscored_word)[1..-1]
+    end
+  end
+end
+
+module Vimeo
+  module Advanced
+
+    class RequestFailed < StandardError; end
+
+    class Base
+      extend CreateApiMethod
+      
+      ENDPOINT = "http://vimeo.com/api/rest/v2"
+
+      def initialize(consumer_key, consumer_secret, options = {})
+        @oauth_consumer = OAuth::Consumer.new(consumer_key, consumer_secret, :site => 'http://vimeo.com', :http_method => :get, :scheme => :header)
+        unless options[:token].nil? && options[:secret].nil?
+          @access_token = OAuth::AccessToken.new(@oauth_consumer, options[:token], options[:secret])
+        end
+      end
+      
+      def authorize_url(permission = "delete")
+        get_request_token.authorize_url :permission => permission
+      end
+      
+      def get_request_token
+        @request_token ||= @oauth_consumer.get_request_token :scheme => :header
+      end
+      
+      def get_access_token(oauth_token=nil, oauth_secret=nil, oauth_verifier=nil)
+        @access_token ||= OAuth::RequestToken.new(@oauth_consumer, oauth_token, oauth_secret).get_access_token :oauth_verifier => oauth_verifier
+      end
+      
+      # TODO: Move this to OAuth
+      create_api_method :check_access_token,
+                        "vimeo.oauth.checkAccessToken"
+      
+private
+
+      def make_request(options, authorized)
+        if authorized
+          raw_response = @oauth_consumer.request(:post, Vimeo::Advanced::Base::ENDPOINT, get_access_token, {}, options).body
+        else
+          raw_response = @oauth_consumer.request(:post, Vimeo::Advanced::Base::ENDPOINT, nil, {}, options).body
+        end
+        
+        response = MultiJson.decode(raw_response)
+        validate_response! response
+        response
+      end
+      
+      # Raises an exception if the response does contain a +stat+ different from "ok"
+      def validate_response!(response)
+        raise "empty response" unless response
+        
+        status = response["stat"]
+        if status and status != "ok"
+          error = response["err"]
+          if error
+            raise RequestFailed, "#{error["code"]}: #{error["msg"]}, explanation: #{error["expl"]}"
+          else
+            raise RequestFailed, "Error: #{status}, no error message"
+          end
+        end
+      end
+
+    end # Base
+  end # Advanced
+end # Vimeo