youtube_it 0.0.8 → 1.0.0

data/.gitignore

@@ -14,4 +14,4 @@ db/sphinx/
 sphinx/**/*
 public/packages/*
 .gitconfig
-
+pkg/**/*

data/Rakefile

@@ -9,6 +9,7 @@ begin
     gem.description = %Q{Upload, delete, update, comment on youtube videos all from one gem.}
     gem.email = "kylejginavan@gmail.com"
     gem.homepage = "http://github.com/kylejginavan/youtube_it"
+    gem.add_dependency('oauth','>=0.4.4')
     gem.authors = ["chebyte","kylejginavan"]
   end
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1,2 +1 @@
-0.0.8
-
+1.0.0

data/lib/youtube_it.rb

@@ -4,6 +4,7 @@ require 'net/https'
 require 'digest/md5'
 require 'rexml/document'
 require 'builder'
+require 'oauth'
 
 class YouTubeIt
   

data/lib/youtube_it/client.rb

@@ -180,12 +180,28 @@ class YouTubeIt
   end
 
   class OAuthClient < Client
-    def initialize ctoken = nil, csecret = nil, user = nil, dev_key = nil, client_id = 'youtube_it', legacy_debug_flag = nil
-      @consumer_key, @consumer_secret, @user, @dev_key, @client_id = ctoken, csecret, user, dev_key, client_id
+    def initialize *params
+      if params.first.is_a?(Hash)
+        hash_options = params.first
+        @consumer_key                  = hash_options[:consumer_key]
+        @consumer_secret               = hash_options[:consumer_secret]
+        @user                          = hash_options[:username]
+        @dev_key                       = hash_options[:dev_key]
+        @client_id                     = hash_options[:client_id] || "youtube_it"
+        @legacy_debug_flag             = hash_options[:debug]
+      else
+        puts "* warning: the method YouTubeIt::OAuthClient.new(consumer_key, consumer_secrect, dev_key) is depricated, use YouTubeIt::OAuthClient.new(:consumer_key => 'consumer key', :consumer_secret => 'consumer secret', :dev_key => 'dev_key')"
+        @consumer_key               = params.shift
+        @consumer_secret            = params.shift
+        @dev_key                    = params.shift
+        @user                       = params.shift
+        @client_id                  = params.shift || "youtube_it"
+        @legacy_debug_flag          = params.shift
+      end
     end
 
     def consumer
-      @consumer ||= OAuth::Consumer.new(@consumer_key,@consumer_secret,{
+      @consumer ||= ::OAuth::Consumer.new(@consumer_key,@consumer_secret,{
         :site=>"https://www.google.com",
         :request_token_path=>"/accounts/OAuthGetRequestToken",
         :authorize_path=>"/accounts/OAuthAuthorizeToken",
@@ -197,11 +213,11 @@ class YouTubeIt
     end
 
     def access_token
-      @access_token = OAuth::AccessToken.new(consumer, @atoken, @asecret)
+      @access_token = ::OAuth::AccessToken.new(consumer, @atoken, @asecret)
     end
 
     def authorize_from_request(rtoken,rsecret,verifier)
-      request_token = OAuth::RequestToken.new(consumer,rtoken,rsecret)
+      request_token = ::OAuth::RequestToken.new(consumer,rtoken,rsecret)
       access_token = request_token.get_access_token({:oauth_verifier => verifier})
       @atoken,@asecret = access_token.token, access_token.secret
     end

data/lib/youtube_it/request/video_search.rb

@@ -14,6 +14,8 @@ class YouTubeIt
       attr_reader :video_format                    # format (1=mobile devices)
       attr_reader :racy                            # racy ([exclude], include)
       attr_reader :author
+      attr_reader :lang                            # lt
+
 
       def initialize(params={})
         # Initialize our various member data to avoid warnings and so we'll
@@ -21,7 +23,7 @@ class YouTubeIt
         @max_results, @order_by,
         @offset, @query,
         @response_format, @video_format,
-        @racy, @author = nil
+        @racy, @author, @lang = nil
         @url = base_url
         @dev_key = params[:dev_key] if params[:dev_key]
 
@@ -56,7 +58,8 @@ class YouTubeIt
           'alt' => @response_format,
           'format' => @video_format,
           'racy' => @racy,
-          'author' => @author
+          'author' => @author,
+          'lr' => @lang
         }
       end
 

data/lib/youtube_it/request/video_upload.rb

@@ -51,40 +51,38 @@ class YouTubeIt
       # errors, containing the key and its error code.
       #
       # When the authentication credentials are incorrect, an AuthenticationError will be raised.
-      def upload data, opts = {}
-        response = ""
-        @opts = { :mime_type => 'video/mp4',
-                  :title => '',
-                  :description => '',
-                  :category => '',
-                  :keywords => [] }.merge(opts)
+      def upload(data, opts = {})
+        response = nil
+        @opts    = { :mime_type => 'video/mp4',
+                     :title => '',
+                     :description => '',
+                     :category => '',
+                     :keywords => [] }.merge(opts)
 
         @opts[:filename] ||= generate_uniq_filename_from(data)
 
         post_body_io = generate_upload_io(video_xml, data)
 
-        upload_headers = {
+        upload_header = {
             "Slug"           => "#{@opts[:filename]}",
             "Content-Type"   => "multipart/related; boundary=#{boundary}",
-            "Content-Length" => "#{post_body_io.expected_length}", # required per YouTube spec
-          # "Transfer-Encoding" => "chunked" # We will stream instead of posting at once
+            "Content-Length" => "#{post_body_io.expected_length}",
         }
 
         if @access_token.nil?
-          upload_headers.merge!(authorization_headers)
+          upload_header.merge!(authorization_headers).delete("GData-Version")
           http = Net::HTTP.new(uploads_url)
           http.set_debug_output(logger) if @http_debugging
-          path = '/feeds/api/users/%s/uploads' % @user
+          path = '/feeds/api/users/default/uploads'
           http.start do | session |
-            # Use the chained IO as body so that Net::HTTP reads into the socket for us
-            post = Net::HTTP::Post.new(path, upload_headers)
+            post = Net::HTTP::Post.new(path, upload_header)
             post.body_stream = post_body_io
             response = session.request(post)
           end
         else
-          upload_headers.merge!(authorization_headers_for_soap)
-          url = 'http://%s/feeds/api/users/%s/uploads' % [uploads_url, @user]
-          response = @access_token.post(url, post_body_io, upload_headers)
+          upload_header.merge!(authorization_headers_for_oauth).delete("GData-Version")
+          url = 'http://%s/feeds/api/users/default/uploads' % uploads_url
+          response = @access_token.post(url, post_body_io, upload_header)
         end
         raise_on_faulty_response(response)
         return YouTubeIt::Parser::VideoFeedParser.new(response.body).parse
@@ -99,18 +97,14 @@ class YouTubeIt
       #   :private
       # When the authentication credentials are incorrect, an AuthenticationError will be raised.
       def update(video_id, options)
-        response = ""
+        response = nil
         @opts = options
-
         update_body = video_xml
-
         update_header = {
-          "GData-Version" => "2",
           "Content-Type"   => "application/atom+xml",
           "Content-Length" => "#{update_body.length}",
         }
-
-        update_url = "/feeds/api/users/#{@user}/uploads/#{video_id}"
+        update_url = "/feeds/api/users/default/uploads/%s" % video_id
 
         if @access_token.nil?
           update_header.merge!(authorization_headers)
@@ -118,8 +112,8 @@ class YouTubeIt
             response = session.put(update_url, update_body, update_header)
           end
         else
-          upload_headers.merge!(authorization_headers_for_soap)
-          response = @access_token.put("http://"+base_url+update_url, update_body, update_header)
+          update_header.merge!(authorization_headers_for_oauth)
+          response = @access_token.put("http://%s%s" % [base_url,update_url], update_body, update_header)
         end
 
         raise_on_faulty_response(response)
@@ -128,65 +122,74 @@ class YouTubeIt
 
       # Delete a video on YouTube
       def delete(video_id)
+        response      = nil
         delete_header = {
           "Content-Type"   => "application/atom+xml; charset=UTF-8",
           "Content-Length" => "0",
         }
-
-        delete_url = "/feeds/api/users/#{@user}/uploads/#{video_id}"
+        delete_url = "/feeds/api/users/default/uploads/%s" % video_id
 
         if @access_token.nil?
           delete_header.merge!(authorization_headers)
           http_connection do |session|
             response = session.delete(delete_url, delete_header)
-            raise_on_faulty_response(response)
           end
         else
-          upload_headers.merge!(authorization_headers_for_soap)
-          response = @access_token.delete("http://"+base_url+delete_url, delete_header)
-          raise_on_faulty_response(response)
+          delete_header.merge!(authorization_headers_for_oauth)
+          response = @access_token.delete("http://%s%s" % [base_url,delete_url], delete_header)
         end
-
+        raise_on_faulty_response(response)
         return true
       end
 
       def get_upload_token(options, nexturl)
-        @opts = options
-
+        response      = nil
+        @opts         = options
         token_body    = video_xml
-        token_header  = authorization_headers.merge({
+        token_header  = {
           "Content-Type"   => "application/atom+xml; charset=UTF-8",
           "Content-Length" => "#{token_body.length}",
-        })
+        }
         token_url = "/action/GetUploadToken"
-
-        http_connection do |session|
-          response = session.post(token_url, token_body, token_header)
-          raise_on_faulty_response(response)
-          return {:url    => "#{response.body[/<url>(.+)<\/url>/, 1]}?nexturl=#{nexturl}",
-                  :token  => response.body[/<token>(.+)<\/token>/, 1]}
+        
+        if @access_token.nil?
+          token_header.merge!(authorization_headers)
+          http_connection do |session|
+            response = session.post(token_url, token_body, token_header)
+          end
+        else
+          token_header.merge!(authorization_headers_for_oauth)
+          response = @access_token.post("http://%s%s" % [base_url, token_url], token_body, token_header)
         end
+        raise_on_faulty_response(response)
+        return {:url    => "#{response.body[/<url>(.+)<\/url>/, 1]}?nexturl=#{nexturl}",
+                :token  => response.body[/<token>(.+)<\/token>/, 1]}
       end
 
       def add_comment(video_id, comment)
-        comment_body   = video_xml_for(:comment => comment)
-        comment_header = authorization_headers.merge({
-          "GData-Version" => "2",
+        response        = nil
+        comment_body    = video_xml_for(:comment => comment)
+        comment_header  = {
           "Content-Type"   => "application/atom+xml",
           "Content-Length" => "#{comment_body.length}",
-        })
-
-        comment_url = "/feeds/api/videos/#{video_id}/comments"
+        }
+        comment_url = "/feeds/api/videos/%s/comments" % video_id
 
-        http_connection do |session|
-          response = session.post(comment_url, comment_body, comment_header)
-          raise_on_faulty_response(response)
-          {:code => response.code, :body => response.body}
+        if @access_token.nil?
+          comment_header.merge!(authorization_headers)
+          http_connection do |session|
+            response = session.post(comment_url, comment_body, comment_header)
+          end
+        else
+          comment_header.merge!(authorization_headers_for_oauth)
+          response = @access_token.post("http://%s%s" % [base_url, comment_url], comment_body, comment_header)
         end
+        raise_on_faulty_response(response)
+        {:code => response.code, :body => response.body}
       end
 
       def comments(video_id)
-        comment_url = "/feeds/api/videos/#{video_id}/comments"
+        comment_url = "/feeds/api/videos/%s/comments" % video_id
         http_connection do |session|
           response = session.get(comment_url)
           raise_on_faulty_response(response)
@@ -195,39 +198,50 @@ class YouTubeIt
       end
 
       def add_favorite(video_id)
+        response        = nil
         favorite_body   = video_xml_for(:favorite => video_id)
-        favorite_header = authorization_headers.merge({
-          "GData-Version" => "2",
+        favorite_header = {
           "Content-Type"   => "application/atom+xml",
           "Content-Length" => "#{favorite_body.length}",
-        })
-
-        favorite_url = "/feeds/api/users/#{@user}/favorites"
-
-        http_connection do |session|
-          response = session.post(favorite_url, favorite_body, favorite_header)
-          raise_on_faulty_response(response)
-          {:code => response.code, :body => response.body}
+        }
+        favorite_url = "/feeds/api/users/default/favorites"
+        
+        if @access_token.nil?
+          favorite_header.merge!(authorization_headers)
+          http_connection do |session|
+            response = session.post(favorite_url, favorite_body, favorite_header)
+          end
+        else
+          favorite_header.merge!(authorization_headers_for_oauth)
+          response = @access_token.post("http://%s%s" % [base_url, favorite_url], favorite_body, favorite_header)
         end
+        raise_on_faulty_response(response)
+        {:code => response.code, :body => response.body}
       end
 
       def delete_favorite(video_id)
-        favorite_header = authorization_headers.merge({
+        response        = nil
+        favorite_header = {
           "Content-Type"   => "application/atom+xml; charset=UTF-8",
           "Content-Length" => "0",
-        })
-
-        favorite_url = "/feeds/api/users/#{@user}/favorites/#{video_id}"
-
-        http_connection do |session|
-          response = session.delete(favorite_url, favorite_header)
-          raise_on_faulty_response(response)
-          return true
+        }
+        favorite_url    = "/feeds/api/users/default/favorites/%s" % video_id
+        
+        if @access_token.nil?
+          favorite_header.merge!(authorization_headers).delete("GData-Version")
+          http_connection do |session|
+            response = session.delete(favorite_url, favorite_header)
+          end
+        else
+          favorite_header.merge!(authorization_headers_for_oauth).delete("GData-Version")
+          response = @access_token.delete("http://%s%s" % [base_url, favorite_url], favorite_header)
         end
+        raise_on_faulty_response(response)
+        return true
       end
 
       def playlist(playlist_id)
-        playlist_url = "/feeds/api/playlists/#{playlist_id}?v=2"
+        playlist_url = "/feeds/api/playlists/%s?v=2" % playlist_id
         http_connection do |session|
           response = session.get(playlist_url)
           raise_on_faulty_response(response)
@@ -236,7 +250,7 @@ class YouTubeIt
       end
 
       def playlists
-        playlist_url = "/feeds/api/users/#{@user}/playlists?v=2"
+        playlist_url = "/feeds/api/users/default/playlists?v=2"
         http_connection do |session|
           response = session.get(playlist_url)
           raise_on_faulty_response(response)
@@ -245,89 +259,113 @@ class YouTubeIt
       end
 
       def add_playlist(options)
+        response        = nil
         playlist_body   = video_xml_for_playlist(options)
-        playlist_header = authorization_headers.merge({
-          "GData-Version" => "2",
+        playlist_header = {
           "Content-Type"   => "application/atom+xml",
           "Content-Length" => "#{playlist_body.length}",
-        })
-
-        playlist_url = "/feeds/api/users/#{@user}/playlists"
+        }
+        playlist_url = "/feeds/api/users/default/playlists"
 
-        http_connection do |session|
-          response = session.post(playlist_url, playlist_body, playlist_header)
-          raise_on_faulty_response(response)
-          return YouTubeIt::Parser::PlaylistFeedParser.new(response).parse
+        if @access_token.nil?
+          playlist_header.merge!(authorization_headers)
+          http_connection do |session|
+            response = session.post(playlist_url, playlist_body, playlist_header)
+          end
+        else
+          playlist_header.merge!(authorization_headers_for_oauth)
+          response = @access_token.post("http://%s%s" % [base_url, playlist_url], playlist_body, playlist_header)
         end
+        raise_on_faulty_response(response)
+        return YouTubeIt::Parser::PlaylistFeedParser.new(response).parse
       end
 
       def add_video_to_playlist(playlist_id, video_id)
+        response        = nil
         playlist_body   = video_xml_for(:playlist => video_id)
-        playlist_header = authorization_headers.merge({
-          "GData-Version" => "2",
+        playlist_header = {
           "Content-Type"   => "application/atom+xml",
           "Content-Length" => "#{playlist_body.length}",
-        })
-
-        playlist_url = "/feeds/api/playlists/#{playlist_id}"
+        }
+        playlist_url = "/feeds/api/playlists/%s" % playlist_id
 
-        http_connection do |session|
-          response = session.post(playlist_url, playlist_body, playlist_header)
-          raise_on_faulty_response(response)
-          {:code => response.code, :body => response.body, :playlist_entry_id => playlist_entry_id_from_playlist(response.body)}
+        if @access_token.nil?
+          playlist_header.merge!(authorization_headers)
+          http_connection do |session|
+            response = session.post(playlist_url, playlist_body, playlist_header)
+          end
+        else
+          playlist_header.merge!(authorization_headers_for_oauth)
+          response = @access_token.post("http://%s%s" % [base_url, playlist_url], playlist_body, playlist_header)
         end
+        raise_on_faulty_response(response)
+        {:code => response.code, :body => response.body, :playlist_entry_id => playlist_entry_id_from_playlist(response.body)}
       end
 
       def update_playlist(playlist_id, options)
+        response        = nil
         playlist_body   = video_xml_for_playlist(options)
-        playlist_header = authorization_headers.merge({
-          "GData-Version" => "2",
+        playlist_header = {
           "Content-Type"   => "application/atom+xml",
           "Content-Length" => "#{playlist_body.length}",
-        })
-        playlist_url = "/feeds/api/users/#{@user}/playlists/#{playlist_id}"
+        }
+        playlist_url = "/feeds/api/users/default/playlists/%s" % playlist_id
 
-        http_connection do |session|
-          response = session.put(playlist_url, playlist_body, playlist_header)
-          raise_on_faulty_response(response)
-          return YouTubeIt::Parser::PlaylistFeedParser.new(response).parse
+        if @access_token.nil?
+          playlist_header.merge!(authorization_headers)
+          http_connection do |session|
+            response = session.put(playlist_url, playlist_body, playlist_header)
+          end
+        else
+          playlist_header.merge!(authorization_headers_for_oauth)
+          response = @access_token.put("http://%s%s" % [base_url, playlist_url], playlist_body, playlist_header)
         end
+        raise_on_faulty_response(response)
+        return YouTubeIt::Parser::PlaylistFeedParser.new(response).parse
       end
 
-
       def delete_video_from_playlist(playlist_id, playlist_entry_id)
+        response        = nil
         playlist_header = {
           "Content-Type"   => "application/atom+xml",
-          "GData-Version" => "2",
-          "X-GData-Key"    => "key=#{@dev_key}",
-          "Authorization"  => "GoogleLogin auth=#{auth_token}",
         }
+        playlist_url = "/feeds/api/playlists/%s/%s" % [playlist_id, playlist_entry_id]
 
-        playlist_url = "/feeds/api/playlists/#{playlist_id}/#{playlist_entry_id}"
-
-        http_connection do |session|
-          response = session.delete(playlist_url, playlist_header)
-          raise_on_faulty_response(response)
-          return true
+        if @access_token.nil?
+          playlist_header.merge!(authorization_headers)
+          http_connection do |session|
+            response = session.delete(playlist_url, playlist_header)
+          end
+        else
+          playlist_header.merge!(authorization_headers_for_oauth)
+          response = @access_token.delete("http://%s%s" % [base_url, playlist_url], playlist_header)
         end
+        raise_on_faulty_response(response)
+        return true
       end
 
       def delete_playlist(playlist_id)
-        playlist_header = authorization_headers.merge({
+        response        = nil
+        playlist_header = {
           "Content-Type"   => "application/atom+xml; charset=UTF-8",
-          "GData-Version" => "2"
-        })
+        }
+        playlist_url = "/feeds/api/users/default/playlists/%s" % playlist_id
 
-        playlist_url = "/feeds/api/users/#{@user}/playlists/#{playlist_id}"
-        http_connection do |session|
-          response = session.delete(playlist_url, playlist_header)
-          raise_on_faulty_response(response)
-          return true
+        if @access_token.nil?
+          playlist_header.merge!(authorization_headers)
+          http_connection do |session|
+            response = session.delete(playlist_url, playlist_header)
+          end
+        else
+          playlist_header.merge!(authorization_headers_for_oauth)
+          response = @access_token.delete("http://%s%s" % [base_url, playlist_url], playlist_header)
         end
+        raise_on_faulty_response(response)
+        return true
       end
 
       def favorites
-        favorite_url = "/feeds/api/users/#{@user}/favorites"
+        favorite_url = "/feeds/api/users/default/favorites"
         http_connection do |session|
           response = session.get(favorite_url)
           raise_on_faulty_response(response)
@@ -349,9 +387,11 @@ class YouTubeIt
         "An43094fu"
       end
 
-      def authorization_headers_for_soap
+      def authorization_headers_for_oauth
         {
-          "X-GData-Key"    => "key=#{@dev_key}"
+          "X-GData-Client" => "#{@client_id}",
+          "X-GData-Key"    => "key=#{@dev_key}",
+          "GData-Version"  => "2",
         }
       end
 
@@ -359,7 +399,8 @@ class YouTubeIt
         {
           "Authorization"  => "GoogleLogin auth=#{auth_token}",
           "X-GData-Client" => "#{@client_id}",
-          "X-GData-Key"    => "key=#{@dev_key}"
+          "X-GData-Key"    => "key=#{@dev_key}",
+          "GData-Version" => "2",
         }
       end
 
@@ -495,5 +536,4 @@ class YouTubeIt
       end
     end
   end
-end
-
+end

data/test/test_client.rb

@@ -15,170 +15,170 @@ class TestClient < Test::Unit::TestCase
 
   def test_should_respond_to_a_basic_query
     response = @client.videos_by(:query => "penguin")
-
+  
     assert_equal "http://gdata.youtube.com/feeds/api/videos", response.feed_id
     assert_equal 25, response.max_result_count
     assert_equal 25, response.videos.length
     assert_equal 1, response.offset
     assert(response.total_result_count > 100)
     assert_instance_of Time, response.updated_at
-
+  
     response.videos.each { |v| assert_valid_video v }
   end
-
+  
     def test_should_respond_to_a_basic_query_with_offset_and_max_results
     response = @client.videos_by(:query => "penguin", :offset => 15, :max_results => 30)
-
+  
     assert_equal "http://gdata.youtube.com/feeds/api/videos", response.feed_id
     assert_equal 30, response.max_result_count
     assert_equal 30, response.videos.length
     assert_equal 15, response.offset
     assert(response.total_result_count > 100)
     assert_instance_of Time, response.updated_at
-
+  
     response.videos.each { |v| assert_valid_video v }
   end
-
+  
   def test_should_respond_to_a_basic_query_with_paging
     response = @client.videos_by(:query => "penguin")
     assert_equal "http://gdata.youtube.com/feeds/api/videos", response.feed_id
     assert_equal 25, response.max_result_count
     assert_equal 1, response.offset
-
+  
       response = @client.videos_by(:query => "penguin", :page => 2)
     assert_equal "http://gdata.youtube.com/feeds/api/videos", response.feed_id
     assert_equal 25, response.max_result_count
     assert_equal 26, response.offset
-
+  
     response2 = @client.videos_by(:query => "penguin", :page => 3)
     assert_equal "http://gdata.youtube.com/feeds/api/videos", response2.feed_id
     assert_equal 25, response2.max_result_count
     assert_equal 51, response2.offset
   end
-
+  
   def test_should_get_videos_for_multiword_metasearch_query
     response = @client.videos_by(:query => 'christina ricci')
-
+  
     assert_equal "http://gdata.youtube.com/feeds/api/videos", response.feed_id
     assert_equal 25, response.max_result_count
     assert_equal 25, response.videos.length
     assert_equal 1, response.offset
     assert(response.total_result_count > 100)
     assert_instance_of Time, response.updated_at
-
+  
     response.videos.each { |v| assert_valid_video v }
   end
-
+  
   def test_should_handle_video_not_yet_viewed
     response = @client.videos_by(:query => "YnqHZDh_t2Q")
-
+  
     assert_equal 1, response.videos.length
     response.videos.each { |v| assert_valid_video v }
   end
-
+  
   def test_should_get_videos_for_one_tag
     response = @client.videos_by(:tags => ['panther'])
     response.videos.each { |v| assert_valid_video v }
   end
-
+  
   def test_should_get_videos_for_multiple_tags
     response = @client.videos_by(:tags => ['tiger', 'leopard'])
     response.videos.each { |v| assert_valid_video v }
   end
-
+  
   def test_should_get_videos_for_one_category
     response = @client.videos_by(:categories => [:news])
     response.videos.each { |v| assert_valid_video v }
   end
-
+  
   def test_should_get_videos_for_multiple_categories
     response = @client.videos_by(:categories => [:news, :sports])
     response.videos.each { |v| assert_valid_video v }
   end
-
+  
   # TODO: Need to do more specific checking in these tests
   # Currently, if a URL is valid, and videos are found, the test passes regardless of search criteria
   def test_should_get_videos_for_categories_and_tags
     response = @client.videos_by(:categories => [:news, :sports], :tags => ['soccer', 'football'])
     response.videos.each { |v| assert_valid_video v }
   end
-
+  
   def test_should_get_most_viewed_videos
     response = @client.videos_by(:most_viewed)
     response.videos.each { |v| assert_valid_video v }
   end
-
+  
   def test_should_get_top_rated_videos_for_today
     response = @client.videos_by(:top_rated, :time => :today)
     response.videos.each { |v| assert_valid_video v }
   end
-
+  
   def test_should_get_videos_for_categories_and_tags_with_category_boolean_operators
     response = @client.videos_by(:categories => { :either => [:news, :sports], :exclude => [:comedy] },
                                  :tags => { :include => ['football'], :exclude => ['soccer'] })
     response.videos.each { |v| assert_valid_video v }
   end
-
+  
   def test_should_get_videos_for_categories_and_tags_with_tag_boolean_operators
     response = @client.videos_by(:categories => { :either => [:news, :sports], :exclude => [:comedy] },
                                  :tags => { :either => ['football', 'soccer', 'polo'] })
     response.videos.each { |v| assert_valid_video v }
   end
-
+  
   def test_should_get_videos_by_user
     response = @client.videos_by(:user => 'liz')
     response.videos.each { |v| assert_valid_video v }
   end
-
+  
   def test_should_get_videos_by_user_with_pagination_and_ordering
     response = @client.videos_by(:user => 'liz', :page => 2, :per_page => '2', :order_by => 'published')
     response.videos.each { |v| assert_valid_video v }
     assert_equal 3, response.offset
     assert_equal 2, response.max_result_count
   end
-
+  
   def test_should_get_favorite_videos_by_user
     response = @client.videos_by(:favorites, :user => 'drnicwilliams')
     assert_equal "http://gdata.youtube.com/feeds/api/users/drnicwilliams/favorites", response.feed_id
     response.videos.each { |v| assert_valid_video v }
   end
-
+  
   def test_should_get_videos_for_query_search_with_categories_excluded
     video = @client.video_by("EkF4JD2rO3Q")
     assert_equal "<object width=\"425\" height=\"350\">\n  <param name=\"movie\" value=\"http://www.youtube.com/v/EkF4JD2rO3Q&feature=youtube_gdata_player\"></param>\n  <param name=\"wmode\" value=\"transparent\"></param>\n  <embed src=\"http://www.youtube.com/v/EkF4JD2rO3Q&feature=youtube_gdata_player\" type=\"application/x-shockwave-flash\"\n   wmode=\"transparent\" width=\"425\" height=\"350\"></embed>\n</object>\n", video.embed_html
     assert_valid_video video
   end
-
+  
   def test_should_get_video_from_user
     video = @client.video_by_user("chebyte","FQK1URcxmb4")
     assert_equal "<object width=\"425\" height=\"350\">\n  <param name=\"movie\" value=\"http://www.youtube.com/v/FQK1URcxmb4&feature=youtube_gdata_player\"></param>\n  <param name=\"wmode\" value=\"transparent\"></param>\n  <embed src=\"http://www.youtube.com/v/FQK1URcxmb4&feature=youtube_gdata_player\" type=\"application/x-shockwave-flash\"\n   wmode=\"transparent\" width=\"425\" height=\"350\"></embed>\n</object>\n", video.embed_html
     assert_valid_video video
   end
-
+  
   def test_should_always_return_a_logger
     @client = YouTubeIt::Client.new
     assert_not_nil @client.logger
   end
-
+  
   def test_should_not_bail_if_debug_is_true
     assert_nothing_raised { YouTubeIt::Client.new(:debug => true) }
   end
-
+  
   def test_should_determine_if_embeddable_video_is_embeddable
     response = @client.videos_by(:query => "strongbad")
-
+  
     video = response.videos.first
     assert video.embeddable?
   end
-
+  
   def test_should_retrieve_video_by_id
     video = @client.video_by("http://gdata.youtube.com/feeds/videos/EkF4JD2rO3Q")
     assert_valid_video video
-
+  
     video = @client.video_by("EkF4JD2rO3Q")
     assert_valid_video video
   end
-
+  
   def test_return_upload_info_for_upload_from_browser
     response = @client.upload_token(OPTIONS)
     assert response.kind_of?(Hash)
@@ -187,13 +187,13 @@ class TestClient < Test::Unit::TestCase
       assert v
     end
   end
-
+  
   def test_should_upload_a_video
     video  = @client.video_upload(File.open("test/test.mov"), OPTIONS)
     assert_valid_video video
     @client.video_delete(video.unique_id)
   end
-
+  
   def test_should_update_a_video
     OPTIONS[:title] = "title changed"
     video  = @client.video_upload(File.open("test/test.mov"), OPTIONS)
@@ -201,13 +201,13 @@ class TestClient < Test::Unit::TestCase
     assert updated_video.title == "title changed"
     @client.video_delete(video.unique_id)
   end
-
+  
   def test_should_delete_video
     video  = @client.video_upload(File.open("test/test.mov"), OPTIONS)
     assert_valid_video video
     assert @client.video_delete(video.unique_id)
   end
-
+  
   def test_should_denied_comments
     video     = @client.video_upload(File.open("test/test.mov"), OPTIONS.merge(:comment => "denied"))
     assert_valid_video video
@@ -215,7 +215,7 @@ class TestClient < Test::Unit::TestCase
     doc.css('.comments-disabled').each{|tag| assert (tag.content.strip == "All Comments\n        \n           Adding comments has been disabled for this video.")}
     @client.video_delete(video.unique_id)
   end
-
+  
   def test_should_denied_rate
     video  = @client.video_upload(File.open("test/test.mov"), OPTIONS.merge(:rate => "denied"))
     assert_valid_video video
@@ -223,20 +223,20 @@ class TestClient < Test::Unit::TestCase
     doc.css('#watch-like').each{|tag|; assert (tag.attributes["title"].to_s == "Ratings have been disabled for this video.")}
     @client.video_delete(video.unique_id)
   end
-
+  
   def test_should_denied_embed
     video  = @client.video_upload(File.open("test/test.mov"), OPTIONS.merge(:embed => "denied"))
     assert    video.noembed
     @client.video_delete(video.unique_id)
   end
-
+  
   def test_should_add_new_comment
     video_id ="H1TrfM3xbgc"
     @client.add_comment(video_id, "test comment")
     comment = @client.comments(video_id)[:body]
     assert comment.match(/test comment/)
   end
-
+  
   def test_shoul_add_and_delete_video_to_favorite
     video_id ="H1TrfM3xbgc"
     result = @client.add_favorite(video_id)
@@ -244,7 +244,7 @@ class TestClient < Test::Unit::TestCase
     sleep 4
     assert @client.delete_favorite(video_id)
   end
-
+  
   def test_should_add_and_del_video_from_playlist
     playlist = @client.add_playlist(:title => "youtube_it test!", :description => "test playlist")
     video = @client.add_video_to_playlist(playlist.playlist_id,"iKqJ8z1DPrQ")
@@ -252,35 +252,36 @@ class TestClient < Test::Unit::TestCase
     assert @client.delete_video_from_playlist(playlist.playlist_id, video[:playlist_entry_id])
     assert @client.delete_playlist(playlist.playlist_id)
   end
-
+  
   def test_should_add_and_del_new_playlist
     result = @client.add_playlist(:title => "youtube_it test!", :description => "test playlist")
     assert result.title, "youtube_it test!"
+    sleep 4
     assert @client.delete_playlist(result.playlist_id)
   end
-
+  
   def test_should_update_playlist
     playlist = @client.add_playlist(:title => "youtube_it test!", :description => "test playlist")
     playlist_updated = @client.update_playlist(playlist.playlist_id, :title => "title changed")
     assert_equal playlist_updated.title, "title changed"
     assert @client.delete_playlist(playlist.playlist_id)
   end
-
+  
   def test_should_determine_if_widescreen_video_is_widescreen
     widescreen_id = 'QqQVll-MP3I'
-
+  
     video = @client.video_by(widescreen_id)
     assert video.widescreen?
   end
-
+  
   private
-
+  
     def assert_valid_video (video)
       # check general attributes
       assert_instance_of YouTubeIt::Model::Video, video
       assert_instance_of Fixnum, video.duration
       assert_instance_of String, video.html_content if video.html_content
-
+  
       # validate media content records
       video.media_content.each do |media_content|
         assert_valid_url media_content.url
@@ -288,20 +289,20 @@ class TestClient < Test::Unit::TestCase
         assert_instance_of String, media_content.mime_type
         assert_match(/^[^\/]+\/[^\/]+$/, media_content.mime_type)
       end
-
+  
       default_content = video.default_media_content
       if default_content
         assert_instance_of YouTubeIt::Model::Content, default_content
         assert default_content.is_default?
       end
-
+  
       # validate keywords
       video.keywords.each { |kw| assert_instance_of(String, kw) }
-
+  
       # http://www.youtube.com/watch?v=IHVaXG1thXM
       assert_valid_url video.player_url
       assert_instance_of Time, video.published_at
-
+  
       # validate optionally-present rating
       if video.rating
         assert_instance_of YouTubeIt::Model::Rating, video.rating
@@ -310,26 +311,26 @@ class TestClient < Test::Unit::TestCase
         assert_instance_of Fixnum, video.rating.min
         assert_instance_of Fixnum, video.rating.rater_count
       end
-
+  
       # validate thumbnails
       assert(video.thumbnails.size > 0)
-
+  
       assert_not_nil video.title
       assert_instance_of String, video.title
       assert(video.title.length > 0)
-
+  
       assert_instance_of Time, video.updated_at
       # http://gdata.youtube.com/feeds/videos/IHVaXG1thXM
       assert_valid_url video.unique_id
       assert_instance_of Fixnum, video.view_count
       assert_instance_of Fixnum, video.favorite_count
-
+  
       # validate author
       assert_instance_of YouTubeIt::Model::Author, video.author
       assert_instance_of String, video.author.name
       assert(video.author.name.length > 0)
       assert_valid_url video.author.uri
-
+  
       # validate categories
       video.categories.each do |cat|
         assert_instance_of YouTubeIt::Model::Category, cat
@@ -337,7 +338,7 @@ class TestClient < Test::Unit::TestCase
         assert_instance_of String, cat.term
       end
     end
-
+  
     def assert_valid_url (url)
       URI::parse(url)
       return true

data/test/test_video_search.rb

@@ -6,12 +6,12 @@ class TestVideoSearch < Test::Unit::TestCase
     request = YouTubeIt::Request::VideoSearch.new(:query => "penguin")
     assert_equal "http://gdata.youtube.com/feeds/api/videos?vq=penguin", request.url
   end
-  
+
   def test_should_build_multiword_metasearch_query_url
     request = YouTubeIt::Request::VideoSearch.new(:query => 'christina ricci')
     assert_equal "http://gdata.youtube.com/feeds/api/videos?vq=christina+ricci", request.url
   end
-  
+
   def test_should_build_video_id_url
     request = YouTubeIt::Request::VideoSearch.new(:video_id => 'T7YazwP8GtY')
     assert_equal "http://gdata.youtube.com/feeds/api/videos/T7YazwP8GtY", request.url
@@ -21,56 +21,62 @@ class TestVideoSearch < Test::Unit::TestCase
     request = YouTubeIt::Request::VideoSearch.new(:tags => ['panther'])
     assert_equal "http://gdata.youtube.com/feeds/api/videos/-/panther/", request.url
   end
-  
+
   def test_should_build_multiple_tags_query_url
     request = YouTubeIt::Request::VideoSearch.new(:tags => ['tiger', 'leopard'])
     assert_equal "http://gdata.youtube.com/feeds/api/videos/-/tiger/leopard/", request.url
   end
-  
+
   def test_should_build_one_category_query_url
     request = YouTubeIt::Request::VideoSearch.new(:categories => [:news])
     assert_equal "http://gdata.youtube.com/feeds/api/videos/-/News/", request.url
   end
-  
+
   def test_should_build_multiple_categories_query_url
     request = YouTubeIt::Request::VideoSearch.new(:categories => [:news, :sports])
     assert_equal "http://gdata.youtube.com/feeds/api/videos/-/News/Sports/", request.url
   end
-  
+
   def test_should_build_categories_and_tags_query_url
     request = YouTubeIt::Request::VideoSearch.new(:categories => [:news, :sports], :tags => ['soccer', 'football'])
     assert_equal "http://gdata.youtube.com/feeds/api/videos/-/News/Sports/soccer/football/", request.url
   end
-  
+
   def test_should_build_categories_and_tags_url_with_max_results
     request = YouTubeIt::Request::VideoSearch.new(:categories => [:music], :tags => ['classic', 'rock'], :max_results => 2)
     assert_equal "http://gdata.youtube.com/feeds/api/videos/-/Music/classic/rock/?max-results=2", request.url
   end
-  
+
   def test_should_build_author_query_url
     request = YouTubeIt::Request::VideoSearch.new(:author => "davidguetta")
     assert_equal "http://gdata.youtube.com/feeds/api/videos?author=davidguetta", request.url
   end
+
+  def test_should_build_language_query_url
+    request = YouTubeIt::Request::VideoSearch.new(:query => 'christina ricci', :lang => 'pt')
+    assert_equal "http://gdata.youtube.com/feeds/api/videos?lr=pt&vq=christina+ricci", request.url
+  end
+
   # -- Standard Feeds --------------------------------------------------------------------------------
-  
+
   def test_should_build_url_for_most_viewed
     request = YouTubeIt::Request::StandardSearch.new(:most_viewed)
-    assert_equal "http://gdata.youtube.com/feeds/api/standardfeeds/most_viewed", request.url    
+    assert_equal "http://gdata.youtube.com/feeds/api/standardfeeds/most_viewed", request.url
   end
-  
+
   def test_should_build_url_for_top_rated_for_today
     request = YouTubeIt::Request::StandardSearch.new(:top_rated, :time => :today)
-    assert_equal "http://gdata.youtube.com/feeds/api/standardfeeds/top_rated?time=today", request.url    
-  end  
-  
+    assert_equal "http://gdata.youtube.com/feeds/api/standardfeeds/top_rated?time=today", request.url
+  end
+
   def test_should_build_url_for_most_viewed_offset_and_max_results_without_time
     request = YouTubeIt::Request::StandardSearch.new(:top_rated, :offset => 5, :max_results => 10)
-    assert_equal "http://gdata.youtube.com/feeds/api/standardfeeds/top_rated?max-results=10&start-index=5", request.url   
+    assert_equal "http://gdata.youtube.com/feeds/api/standardfeeds/top_rated?max-results=10&start-index=5", request.url
   end
-  
+
   def test_should_build_url_for_most_viewed_offset_and_max_results_with_time
     request = YouTubeIt::Request::StandardSearch.new(:top_rated, :offset => 5, :max_results => 10, :time => :today)
-    assert_equal "http://gdata.youtube.com/feeds/api/standardfeeds/top_rated?max-results=10&start-index=5&time=today", request.url   
+    assert_equal "http://gdata.youtube.com/feeds/api/standardfeeds/top_rated?max-results=10&start-index=5&time=today", request.url
   end
 
   def test_should_raise_exception_for_invalid_type
@@ -78,9 +84,9 @@ class TestVideoSearch < Test::Unit::TestCase
       request = YouTubeIt::Request::StandardSearch.new(:most_viewed_yo)
     end
   end
-  
+
   # -- Complex Video Queries -------------------------------------------------------------------------
-  
+
   def test_should_build_url_for_boolean_or_case_for_categories
     request = YouTubeIt::Request::VideoSearch.new(:categories => { :either => [:news, :sports] })
     assert_equal "http://gdata.youtube.com/feeds/api/videos/-/News%7CSports/", request.url
@@ -102,21 +108,21 @@ class TestVideoSearch < Test::Unit::TestCase
                                                  :tags => { :either => ['soccer', 'football', 'donkey'] })
     assert_equal "http://gdata.youtube.com/feeds/api/videos/-/News%7CSports/-Comedy/soccer%7Cfootball%7Cdonkey/", request.url
   end
-  
+
   def test_should_build_url_for_query_search_with_categories_excluded
-    request = YouTubeIt::Request::VideoSearch.new(:query => 'bench press', 
+    request = YouTubeIt::Request::VideoSearch.new(:query => 'bench press',
                                                  :categories => { :exclude => [:comedy, :entertainment] },
                                                  :max_results => 10)
     assert_equal "http://gdata.youtube.com/feeds/api/videos/-/-Comedy/-Entertainment/?max-results=10&vq=bench+press", request.url
   end
-  
+
   # -- User Queries ---------------------------------------------------------------------------------
-  
+
   def test_should_build_url_for_videos_by_user
     request = YouTubeIt::Request::UserSearch.new(:user => 'liz')
     assert_equal "http://gdata.youtube.com/feeds/api/users/liz/uploads", request.url
   end
-  
+
   def test_should_build_url_for_videos_by_user_paginate_and_order
     request = YouTubeIt::Request::UserSearch.new(:user => 'liz', :offset => 20, :max_results => 10, :order_by => 'published')
     assert_equal "http://gdata.youtube.com/feeds/api/users/liz/uploads?max-results=10&orderby=published&start-index=20", request.url
@@ -132,3 +138,4 @@ class TestVideoSearch < Test::Unit::TestCase
     assert_equal "http://gdata.youtube.com/feeds/api/users/liz/favorites?max-results=10&start-index=20", request.url
   end
 end
+

data/youtube_it.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{youtube_it}
-  s.version = "0.0.8"
+  s.version = "1.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["chebyte", "kylejginavan"]
-  s.date = %q{2010-11-09}
+  s.date = %q{2010-11-24}
   s.description = %q{Upload, delete, update, comment on youtube videos all from one gem.}
   s.email = %q{kylejginavan@gmail.com}
   s.extra_rdoc_files = [
@@ -44,6 +44,7 @@ Gem::Specification.new do |s|
      "lib/youtube_it/request/video_upload.rb",
      "lib/youtube_it/response/video_search.rb",
      "lib/youtube_it/version.rb",
+     "pkg/youtube_it-0.0.8.gem",
      "test/helper.rb",
      "test/test.mov",
      "test/test_chain_io.rb",
@@ -70,9 +71,12 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<oauth>, [">= 0.4.4"])
     else
+      s.add_dependency(%q<oauth>, [">= 0.4.4"])
     end
   else
+    s.add_dependency(%q<oauth>, [">= 0.4.4"])
   end
 end
 

metadata

@@ -3,10 +3,10 @@ name: youtube_it
 version: !ruby/object:Gem::Version 
   prerelease: false
   segments: 
+  - 1
   - 0
   - 0
-  - 8
-  version: 0.0.8
+  version: 1.0.0
 platform: ruby
 authors: 
 - chebyte
@@ -15,10 +15,23 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-09 00:00:00 -06:00
+date: 2010-11-24 00:00:00 -06:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: oauth
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 4
+        - 4
+        version: 0.4.4
+  type: :runtime
+  version_requirements: *id001
 description: Upload, delete, update, comment on youtube videos all from one gem.
 email: kylejginavan@gmail.com
 executables: []
@@ -56,6 +69,7 @@ files:
 - lib/youtube_it/request/video_upload.rb
 - lib/youtube_it/response/video_search.rb
 - lib/youtube_it/version.rb
+- pkg/youtube_it-0.0.8.gem
 - test/helper.rb
 - test/test.mov
 - test/test_chain_io.rb