tenderlove-vimeo 1.3.0

data/CHANGELOG.rdoc

@@ -0,0 +1,18 @@
+== 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) 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/Manifest.txt

@@ -0,0 +1,27 @@
+CHANGELOG.rdoc
+LICENSE
+Manifest.txt
+README.rdoc
+Rakefile
+VERSION.yml
+lib/vimeo.rb
+lib/vimeo/advanced.rb
+lib/vimeo/advanced/auth.rb
+lib/vimeo/advanced/base.rb
+lib/vimeo/advanced/contact.rb
+lib/vimeo/advanced/group.rb
+lib/vimeo/advanced/person.rb
+lib/vimeo/advanced/test.rb
+lib/vimeo/advanced/upload.rb
+lib/vimeo/advanced/video.rb
+lib/vimeo/simple.rb
+lib/vimeo/simple/activity.rb
+lib/vimeo/simple/album.rb
+lib/vimeo/simple/base.rb
+lib/vimeo/simple/channel.rb
+lib/vimeo/simple/clip.rb
+lib/vimeo/simple/group.rb
+lib/vimeo/simple/user.rb
+test/advanced/test_upload.rb
+test/test_helper.rb
+vimeo.gemspec

data/README.rdoc

@@ -0,0 +1,171 @@
+= Vimeo API Gem
+
+* http://github.com/matthooks/vimeo
+
+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.

data/Rakefile

@@ -0,0 +1,12 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.spec('vimeo') do
+  developer 'Matt Hooks', "matthooks@gmail.com"
+  self.readme_file   = 'README.rdoc'
+  self.history_file  = 'CHANGELOG.rdoc'
+  self.extra_rdoc_files  = FileList['*.rdoc']
+  self.extra_deps = [['jnunemaker-httparty', '>= 0.2.6']]
+end

data/VERSION.yml

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

data/lib/vimeo/advanced/auth.rb

@@ -0,0 +1,36 @@
+module Vimeo
+  module Advanced
+
+    class Auth < Vimeo::Advanced::Base
+      # Obtains an authorization token.
+      def get_token(frob)
+        sig_options = {
+          :frob => frob,
+          :method => "vimeo.auth.getToken"
+        }
+        
+        make_request sig_options
+      end
+
+      # Obtains a frob.
+      # Used for desktop based authentication.
+      def get_frob
+        sig_options = { :method => "vimeo.auth.getFrob" }
+        
+        make_request sig_options
+      end
+
+      # Tests the validity of an authorization token.
+      def check_token(auth_token)
+        sig_options = {
+          :auth_token => auth_token,
+          :method => "vimeo.auth.checkToken"
+        }
+        
+        make_request sig_options
+      end
+
+    end
+
+  end # Advanced
+end # Vimeo

data/lib/vimeo/advanced/base.rb

@@ -0,0 +1,66 @@
+module Vimeo
+  module Advanced
+
+    class Base
+      include HTTParty
+      base_uri 'vimeo.com'
+
+      # 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 login_link(perms, frob)
+        api_sig = generate_api_sig :perms => perms
+        "http://vimeo.com/services/auth/?api_key=#{@auth[:api_key]}&perms=#{perms}&frob=#{frob}&api_sig=#{api_sig}"
+      end
+
+      # TODO: Implement a function that returns the correct upload URL
+
+      # Generates the proper API signature for a file upload.
+      def upload_sig(ticket_id, auth_token)
+        sig_options = {
+          :ticket_id => ticket_id,
+          :auth_token => auth_token
+        }
+
+        generate_api_sig sig_options
+      end
+
+      private
+
+      # 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
+
+      def make_request(sig_options)
+        api_sig = generate_api_sig sig_options
+        self.class.post "/api/rest", :query => query(sig_options, api_sig)
+      end
+
+      def rand_string len
+        chars = ('a'..'z').to_a + ('A'..'Z').to_a
+        string = ''
+        1.upto(len) { |i| string << chars[rand(chars.size-1)] }
+        string
+      end
+
+    end # Base
+
+  end # Advanced
+end # Vimeo

data/lib/vimeo/advanced/contact.rb

@@ -0,0 +1,18 @@
+module Vimeo
+  module Advanced
+
+    class Contact < Vimeo::Advanced::Base
+
+      def get_list(user_id)
+        sig_options = {
+          :user_id => user_id,
+          :method => "vimeo.contacts.getList"
+        }
+
+        make_request sig_options
+      end
+
+    end
+
+  end # Advanced
+end # Vimeo

data/lib/vimeo/advanced/group.rb

@@ -0,0 +1,19 @@
+module Vimeo
+  module Advanced
+
+    class Group < Vimeo::Advanced::Base
+
+      # Fixme: Only takes group_id as int, not group name
+      def get_members(group_id)
+        sig_options = {
+          :group_id => group_id,
+          :method => "vimeo.groups.getMembers"
+        }
+
+        make_request sig_options
+      end
+
+    end
+
+  end # Advanced
+end # Vimeo

data/lib/vimeo/advanced/person.rb

@@ -0,0 +1,105 @@
+module Vimeo
+  module Advanced
+
+    class Person < Vimeo::Advanced::Base
+
+      def find_by_user_name(username)
+        sig_options = {
+          :username => username,
+          :method => "vimeo.people.findByUserName"
+        }
+
+        make_request sig_options
+      end
+
+      def find_by_email(find_email)
+        sig_options = {
+          :find_email => find_email,
+          :method => "vimeo.people.findByEmail"
+        }
+
+        make_request sig_options
+      end
+
+      def get_info(user_id)
+        sig_options = {
+          :user_id => user_id,
+          :method => "vimeo.people.getInfo"
+        }
+
+        make_request sig_options
+      end
+
+      # TODO: This seems to be returning nil from Vimeo... not implemented?
+      def get_portrait_url(user_id, options={})
+        size = options[:size]
+
+        sig_options = {
+          :user_id => user_id,
+          :method => "vimeo.people.getPortraitUrl"
+        }
+        sig_options.merge! :size => size unless size.nil?
+
+        make_request sig_options
+      end
+
+      # TODO: Not working on Vimeo's side
+      def add_contact(user_id, auth_token)
+        sig_options = {
+          :user_id => user_id,
+          :auth_token => auth_token,
+          :method => "vimeo.people.addContact"
+        }
+
+        make_request sig_options
+      end
+
+      # TODO: Not working on Vimeo's side
+      def remove_contact(user_id, auth_token)
+        sig_options = {
+          :user_id => user_id,
+          :auth_token => auth_token,
+          :method => "vimeo.people.removeContact"
+        }
+
+        make_request sig_options
+      end
+
+      def get_upload_status(user_id, auth_token)
+        sig_options = {
+          :user_id => user_id,
+          :auth_token => auth_token,
+          :method => "vimeo.people.getUploadStatus"
+        }
+
+        make_request sig_options
+      end
+
+      # TODO: Verify input for type?
+      def add_subscription(user_id, type, auth_token)
+        sig_options = {
+          :user_id => user_id,
+          :type => type,
+          :auth_token => auth_token,
+          :method => "vimeo.people.addSubscription"
+        }
+
+        make_request sig_options
+      end
+
+      # TODO: Verify input for type?
+      def remove_subscription(user_id, type, auth_token)
+        sig_options = {
+          :user_id => user_id,
+          :type => type,
+          :auth_token => auth_token,
+          :method => "vimeo.people.removeSubscription"
+        }
+
+        make_request sig_options
+      end
+
+    end
+
+  end # Advanced
+end # Vimeo

data/lib/vimeo/advanced/test.rb

@@ -0,0 +1,40 @@
+module Vimeo
+  module Advanced
+
+    class Test < Vimeo::Advanced::Base
+      # An echo test. Echoes all parameters.
+      # Options can be anything except method, api_key,
+      # and api_sig -- if any of these options are
+      # present they will be overwritten by the proper
+      # values.
+      def echo(options={})
+        options.merge!(:method => "vimeo.test.echo")
+        api_sig = generate_api_sig options
+        options.merge!(:api_sig => api_sig)
+        self.class.post("/api/rest", :query => options)
+      end
+
+      # A null test.
+      def null(auth_token)
+        sig_options = {
+          :auth_token => auth_token,
+          :method => "vimeo.test.null"
+        }
+        
+        make_request sig_options
+      end
+
+      # Tests if the user associated to this token
+      # is able to make authenticated calls.
+      def login(auth_token)
+        sig_options = {
+          :auth_token => auth_token,
+          :method => "vimeo.test.login"
+        }
+        
+        make_request sig_options
+      end
+    end
+
+  end # Advanced
+end # Vimeo

data/lib/vimeo/advanced/upload.rb

@@ -0,0 +1,104 @@
+require 'webrick/httputils'
+
+module Vimeo
+  module Advanced
+
+    class Upload < Vimeo::Advanced::Base
+
+      def get_upload_ticket(auth_token)
+        sig_options = {
+          :auth_token => auth_token,
+          :method => "vimeo.videos.getUploadTicket"
+        }
+
+        make_request sig_options
+      end
+
+      def check_upload_status(ticket_id, auth_token)
+        sig_options = {
+          :ticket_id => ticket_id,
+          :auth_token => auth_token,
+          :method => "vimeo.videos.checkUploadStatus"
+        }
+
+        make_request sig_options
+      end
+
+      ###
+      # Upload +file+ to vimeo with +ticket_id+ and +auth_token+
+      def upload file, ticket_id, auth_token
+        boundary = rand_string 20
+
+        enctype = "multipart/form-data; boundary=#{boundary}"
+
+        file_part = file_to_multipart(file)
+
+        params = {
+          :auth_token => auth_token,
+          :ticket_id  => ticket_id
+        }
+        params[:api_sig] = generate_api_sig params
+
+        data = (params.map { |k,v| param_to_multipart(k,v) } +
+         [file_part]
+        ).map { |part|
+          "--#{boundary}\r\n#{part}"
+        }.join + "--#{boundary}--\r\n"
+
+        uri = URI.parse('http://vimeo.com/services/upload')
+
+        http_ctx  = Net::HTTP.new(uri.host, uri.port)
+        request   = Net::HTTP::Post.new(uri.request_uri)
+        request['Content-Type'] = enctype
+        request['Content-Length'] = data.size.to_s
+        http_ctx.request(request, data)
+      end
+
+      def signature_for_file_upload(ticket_id, auth_token)
+        sig_options = {
+          :ticket_id => ticket_id,
+          :auth_token => auth_token
+        }
+        generate_api_sig sig_options
+      end
+
+      private
+      def mime_value_quote(str)
+        str.to_s.gsub(/(["\r\\])/){|s| '\\' + s}
+      end
+
+      def param_to_multipart name, value
+        "Content-Disposition: form-data; name=\"#{mime_value_quote(name)}\"" +
+          "\r\n#{value}\r\n"
+      end
+
+      def file_to_multipart file
+        file_name = File.basename(file)
+
+        headers = nil
+
+        File.open(file, 'rb') { |fh|
+
+          mime_type = WEBrick::HTTPUtils.mime_type(
+            file,
+            WEBrick::HTTPUtils::DefaultMimeTypes
+          )
+
+          headers = [
+            "Content-Disposition: form-data; name=\"" +
+                  "#{mime_value_quote(file)}\"; " +
+                  "filename=\"#{mime_value_quote(file_name)}\"",
+            "Content-Transfer-Encoding: binary",
+          ]
+
+          headers << "Content-Type: #{mime_type}" if mime_type
+          headers << nil
+          headers << fh.read
+        }
+        headers.join("\r\n") + "\r\n"
+      end
+
+    end
+
+  end # Advanced
+end # Vimeo