youtube_it 2.0.0 → 2.0.1

data/README.rdoc

@@ -27,6 +27,9 @@ Client with developer key:
 Client with youtube account and developer key:
   $ client = YouTubeIt::Client.new(:username => "youtube_username", :password =>  "youtube_passwd", :dev_key => "developer_key")
 
+Client with AuthSub:
+    $ client = YouTubeIt::AuthSubClient.new(:token => "token" , :dev_key => "developer_key")
+
 Client with OAuth:
   $ client = YouTubeIt::OAuthClient.new("consumer_key", "consumer_secret", "youtube_username", "developer_key")
   $ client.authorize_from_access("access_token", "access_secret")
@@ -58,9 +61,11 @@ Advanced Queries (with boolean operators OR (either), AND (include), NOT (exclud
 Fields Parameter(experimental features):
   Return videos more than 1000 views
   $ client.videos_by(:fields => {:view_count => "1000"})
+
   Filter by date
   $ client.videos_by(:fields => {:published  => ((Date.today)})
   $ client.videos_by(:fields => {:recorded   => ((Date.today)})  
+
   Filter by date with range
   $ client.videos_by(:fields => {:published  => ((Date.today - 30)..(Date.today))})
   $ client.videos_by(:fields => {:recorded   => ((Date.today - 30)..(Date.today))})  
@@ -88,7 +93,7 @@ My Video:
   $ client.my_video(video_id)
   
 Profile Details:
-  $ client.profile(user_id)
+  $ client.profile(user) #default: current user
 
 List Comments:
   $ client.comments(video_id)
@@ -97,7 +102,7 @@ Add A Comment:
   $ client.add_comment(video_id, "test comment!")
 
 List Favorites:
-  $ client.favorites(user) # current user by default
+  $ client.favorites(user) # default: current user
 
 Add Favorite:
   $ client.add_favorite(video_id)
@@ -112,7 +117,7 @@ Dislike A Video:
   $ client.dislike_video(video_id)
 
 List Subscriptions:
-  $ client.subscriptions(user) #default: current user
+  $ client.subscriptions(user) # default: current user
 
 Subscribe To A Channel:
   $ client.subscribe_channel(channel_name)
@@ -121,7 +126,7 @@ Unsubscribe To A Channel:
   $ client.unsubscribe_channel(subscription_id)
 
 List Playlists:
-  $ client.playlists(user) # current user by default
+  $ client.playlists(user) # default: current user
 
 Select Playlist:
   $ client.playlist(playlist_id)
@@ -190,6 +195,16 @@ If the videos has support for widescreen:
 
 Note: you can specify width or just use the default of 1280.
 
+== USING HTML5
+
+Now you can embed videos without use flash using html5, usefull for mobiles that not support flash but has html5 browser
+
+You can specify these options
+  $ video.embed_html5({:class => 'video-player', :id => 'my-video', :width => '425', :height => '350', :frameborder => '1'})
+
+or just use with default options
+  $ video.embed_html5 #default: width: 425, height: 350, frameborder: 0
+
 == LOGGING
 
 YouTubeIt passes all logs through the logger variable on the class itself. In Rails context, assign the Rails logger to that variable to collect the messages
@@ -197,11 +212,19 @@ YouTubeIt passes all logs through the logger variable on the class itself. In Ra
   $ YouTubeIt.logger = RAILS_DEFAULT_LOGGER
   $ RAILS_DEFAULT_LOGGER.level = Logger::DEBUG
 
+== Example Rails 3 App
+
+You can get an example how you can use youtube_it with Rails 3 here: http://github.com/chebyte/youtube_it_rails_app_example
+
+== DEMO
+
+You can see to youtube_it in action here: http://youtube-it.heroku.com
+
 == CONTRIBUTORS:
 
 * Kyle J. Ginavan.
 * Mauro Torres - http://github.com/chebyte
-* Marko Seppa - https://github.com/mseppae
+* Marko Seppa  - https://github.com/mseppae
 
 == LICENSE:
 

data/VERSION

@@ -1 +1 @@
-2.0.0
+2.0.1

data/lib/youtube_it/client.rb

@@ -137,6 +137,11 @@ class YouTubeIt
     def profile(user = nil)
       client.profile(user)
     end
+    
+    # Fetches a user's activity feed.
+    def activity(user = nil, opts = {})
+      client.get_activity(user, opts)
+    end
 
     def playlist(playlist_id)
       client.playlist playlist_id
@@ -203,6 +208,11 @@ class YouTubeIt
     def my_videos(opts = {})
       client.get_my_videos(opts)
     end
+    
+    # Get's all of the user's contacts/friends. 
+    def my_contacts(opts = {})
+      client.get_my_contacts(opts)
+    end
 
     private
 
@@ -345,7 +355,13 @@ class YouTubeIt
     end
 
     def current_user
-      body = access_token.get("http://gdata.youtube.com/feeds/api/users/default").body
+      yt_session = Faraday.new(:url => "http://gdata.youtube.com") do |builder|
+        builder.use Faraday::Response::YouTubeIt 
+        builder.use Faraday::Request::OAuth, config_token
+        builder.adapter Faraday.default_adapter          
+      end
+      
+      body = yt_session.get("/feeds/api/users/default").body
       REXML::Document.new(body).elements["entry"].elements['author'].elements['name'].text
     end
 

data/lib/youtube_it/middleware/faraday_authheader.rb

@@ -2,7 +2,18 @@ module Faraday
   class Request::AuthHeader < Faraday::Middleware
 
     def call(env)
-      env[:request_headers].merge!(@headers)
+      req_headers = env[:request_headers]
+      req_headers.merge!(@headers)
+      unless req_headers.include?("GData-Version")
+        req_headers.merge!("GData-Version" => "2")
+      end
+      unless req_headers.include?("Content-Type")
+        req_headers.merge!("Content-Type"  => "application/atom+xml; charset=UTF-8")
+      end
+      unless req_headers.include?("Content-Length")
+        req_headers.merge!("Content-Length"  => env[:body] ? "#{env[:body].length}" : "0")
+      end
+
       @app.call(env)
     end
 

data/lib/youtube_it/model/activity.rb

@@ -0,0 +1,17 @@
+class YouTubeIt
+  module Model
+    class Activity < YouTubeIt::Record
+      # Attributes common to multiple activity types
+      attr_reader :type, :author, :videos, :video_id, :time
+      
+      # video_rated
+      attr_reader :user_rating, :video_rating
+      
+      # video_commented
+      attr_reader :comment_thread_url, :video_url
+      
+      # friend_added and user_subscription_added
+      attr_reader :username
+    end
+  end
+end

data/lib/youtube_it/model/author.rb

@@ -6,6 +6,8 @@ class YouTubeIt
       
       # *String*: Feed URL of the author.
       attr_reader :uri
+      
+      attr_reader :thumbnail_url
     end
   end
 end

data/lib/youtube_it/model/comment.rb

@@ -5,6 +5,11 @@ class YouTubeIt
 
       # YouTubeIt::Model::Author:: Information about the YouTube user who owns a piece of video content.
       attr_reader :author
+      
+      # unique ID of the comment.
+      def unique_id
+        url.split("/").last
+      end
     end
   end
 end

data/lib/youtube_it/model/contact.rb

@@ -11,6 +11,9 @@ class YouTubeIt
       
       # *String*:: The Youtube username of the contact.
       attr_reader :username
+      
+      # *String*:: The Youtube title of the contact.
+      attr_reader :title
     end
   end
 end

data/lib/youtube_it/model/user.rb

@@ -21,6 +21,7 @@ class YouTubeIt
       attr_reader :username
       attr_reader :videos_watched
       attr_reader :view_count
+      attr_reader :avatar
     end
   end
 end

data/lib/youtube_it/model/video.rb

@@ -193,6 +193,22 @@ class YouTubeIt
 EDOC
       end
 
+            # Gives you the HTML 5 to embed the video on your website.
+            # Usefull for mobile that not support flash but has html5 browser
+            # === Returns
+            #   String: The HTML for embedding the video on your website.
+            def embed_html5(params = {})
+              opts = {:class  => params[:class]  || "",
+                      :id     => params[:id]     || "",
+                      :width  => params[:width]  || "425",
+                      :height => params[:height] || "350",
+                      :frameborder => params[:frameborder] || "0"
+                      }
+              <<EDOC
+<iframe class="#{opts[:class]}" id="#{opts[:id]}" type="text/html" width="#{opts[:width]}" height="#{opts[:height]}" src="http://www.youtube.com/embed/#{unique_id}" frameborder="#{opts[:frameborder]}">
+EDOC
+            end
+
       # Gives you the HTML to embed the video on your website.
       #
       # === Returns

data/lib/youtube_it/parser.rb

@@ -2,7 +2,13 @@ class YouTubeIt
   module Parser #:nodoc:
     class FeedParser #:nodoc:
       def initialize(content)
-        @content = open(content).read rescue content
+        @content = open(content).read
+        
+      rescue OpenURI::HTTPError => e
+        raise OpenURI::HTTPError.new(e.io.status[0],e)
+      rescue
+        @content = content
+
       end
 
       def parse
@@ -92,6 +98,155 @@ class YouTubeIt
           :xml           => nil)
       end
     end
+    
+    # Returns an array of the user's activity
+    class ActivityParser < FeedParser
+      def parse_content(content)
+        doc = REXML::Document.new(content.body)
+        feed = doc.elements["feed"]
+        
+        activity = []
+        feed.elements.each("entry") do |entry|
+          parsed_activity = parse_activity(entry)
+          if parsed_activity
+            activity << parsed_activity
+          end
+        end
+        
+        return activity
+      end
+      
+      protected
+      
+      # Parses the user's activity feed.
+      def parse_activity(entry)
+        # Figure out what kind of activity we have
+        video_type = nil
+        parsed_activity = nil
+        entry.elements.each("category") do |category_tag|
+          if category_tag.attributes["scheme"]=="http://gdata.youtube.com/schemas/2007/userevents.cat"
+            video_type = category_tag.attributes["term"]
+          end
+        end
+        
+        if video_type
+          case video_type
+          when "video_rated"
+            parsed_activity = YouTubeIt::Model::Activity.new(
+              :type => "video_rated",
+              :time => entry.elements["updated"] ? entry.elements["updated"].text : nil,
+              :author => entry.elements["author"].elements["name"] ? entry.elements["author"].elements["name"].text : nil,
+              :videos => parse_activity_videos(entry),
+              :video_id => entry.elements["yt:videoid"] ? entry.elements["yt:videoid"].text : nil
+            )
+          when "video_shared"
+            parsed_activity = YouTubeIt::Model::Activity.new(
+              :type => "video_shared",
+              :time => entry.elements["updated"] ? entry.elements["updated"].text : nil,
+              :author => entry.elements["author"].elements["name"] ? entry.elements["author"].elements["name"].text : nil,
+              :videos => parse_activity_videos(entry),
+              :video_id => entry.elements["yt:videoid"] ? entry.elements["yt:videoid"].text : nil
+            )
+          when "video_favorited"
+            parsed_activity = YouTubeIt::Model::Activity.new(
+              :type => "video_favorited",
+              :time => entry.elements["updated"] ? entry.elements["updated"].text : nil,
+              :author => entry.elements["author"].elements["name"] ? entry.elements["author"].elements["name"].text : nil,
+              :videos => parse_activity_videos(entry),
+              :video_id => entry.elements["yt:videoid"] ? entry.elements["yt:videoid"].text : nil
+            )
+          when "video_commented"
+            # Load the comment and video URL
+            comment_thread_url = nil
+            video_url = nil
+            entry.elements.each("link") do |link_tag|
+              case link_tag.attributes["rel"]
+              when "http://gdata.youtube.com/schemas/2007#comments"
+                comment_thread_url = link_tag.attributes["href"]
+              when "http://gdata.youtube.com/schemas/2007#video"
+                video_url = link_tag.attributes["href"]
+              else
+                # Invalid rel type, do nothing
+              end
+            end
+          
+            parsed_activity = YouTubeIt::Model::Activity.new(
+              :type => "video_commented",
+              :time => entry.elements["updated"] ? entry.elements["updated"].text : nil,
+              :author => entry.elements["author"].elements["name"] ? entry.elements["author"].elements["name"].text : nil,
+              :videos => parse_activity_videos(entry),
+              :video_id => entry.elements["yt:videoid"] ? entry.elements["yt:videoid"].text : nil,
+              :comment_thread_url => comment_thread_url,
+              :video_url => video_url
+            )
+          when "video_uploaded"
+            parsed_activity = YouTubeIt::Model::Activity.new(
+              :type => "video_uploaded",
+              :time => entry.elements["updated"] ? entry.elements["updated"].text : nil,
+              :author => entry.elements["author"].elements["name"] ? entry.elements["author"].elements["name"].text : nil,
+              :videos => parse_activity_videos(entry),
+              :video_id => entry.elements["yt:videoid"] ? entry.elements["yt:videoid"].text : nil
+            )
+          when "friend_added"
+            parsed_activity = YouTubeIt::Model::Activity.new(
+              :type => "friend_added",
+              :time => entry.elements["updated"] ? entry.elements["updated"].text : nil,
+              :author => entry.elements["author"].elements["name"] ? entry.elements["author"].elements["name"].text : nil,
+              :username => entry.elements["yt:username"] ? entry.elements["yt:username"].text : nil
+            )
+          when "user_subscription_added"
+            parsed_activity = YouTubeIt::Model::Activity.new(
+              :type => "user_subscription_added",
+              :time => entry.elements["updated"] ? entry.elements["updated"].text : nil,
+              :author => entry.elements["author"].elements["name"] ? entry.elements["author"].elements["name"].text : nil,
+              :username => entry.elements["yt:username"] ? entry.elements["yt:username"].text : nil
+            )
+          else
+            # Invalid activity type, just let it return nil
+          end
+        end
+        
+        return parsed_activity
+      end
+      
+      # If a user enabled inline attribute videos may be included in results.
+      def parse_activity_videos(entry)
+        videos = []
+      
+        entry.elements.each("link") do |link_tag|
+          if link_tag.attributes["rel"]=="http://gdata.youtube.com/schemas/2007#video"
+            videos << YouTubeIt::Parser::VideoFeedParser.new(link_tag).parse
+          end
+        end
+        
+        if videos.size <= 0
+          videos = nil
+        end
+        
+        return videos
+      end
+    end
+    
+    # Returns an array of the user's contacts
+    class ContactsParser < FeedParser
+      def parse_content(content)
+        doc = REXML::Document.new(content.body)
+        feed = doc.elements["feed"]
+        
+        contacts = []
+        feed.elements.each("entry") do |entry|
+          temp_contact = YouTubeIt::Model::Contact.new(
+            :title    => entry.elements["title"] ? entry.elements["title"].text : nil,
+            :username => entry.elements["yt:username"] ? entry.elements["yt:username"].text : nil,
+            :status   => entry.elements["yt:status"] ? entry.elements["yt:status"].text : nil
+          )
+          
+          contacts << temp_contact
+        end
+        
+        return contacts
+      end
+    end
 
     class ProfileFeedParser < FeedParser #:nodoc:
       def parse_content(content)
@@ -112,6 +267,7 @@ class YouTubeIt
           :occupation     => entry.elements["yt:occupation"] ? entry.elements["yt:occupation"].text : nil,
           :relationship   => entry.elements["yt:relationship"] ? entry.elements["yt:relationship"].text : nil,
           :school         => entry.elements["yt:school"] ? entry.elements["yt:school"].text : nil,
+          :avatar         => entry.elements["media:thumbnail"] ? entry.elements["media:thumbnail"].attributes["url"] : nil,
           :subscribers    => entry.elements["yt:statistics"].attributes["subscriberCount"],
           :videos_watched => entry.elements["yt:statistics"].attributes["videoWatchCount"],
           :view_count     => entry.elements["yt:statistics"].attributes["viewCount"],
@@ -148,12 +304,13 @@ class YouTubeIt
     class VideoFeedParser < FeedParser #:nodoc:
 
       def parse_content(content)
-        doc = REXML::Document.new(content)
+        doc = (content.is_a?(REXML::Element)) ? content : REXML::Document.new(content)
+        
         entry = doc.elements["entry"]
         parse_entry(entry)
       end
 
-    protected
+      protected
       def parse_entry(entry)
         video_id = entry.elements["id"].text
         published_at  = entry.elements["published"] ? Time.parse(entry.elements["published"].text) : nil

data/lib/youtube_it/request/video_upload.rb

@@ -88,27 +88,29 @@ class YouTubeIt
       #   :private
       # When the authentication credentials are incorrect, an AuthenticationError will be raised.
       def update(video_id, options)
-        @opts         = options
-        update_body   = video_xml
-        update_header = {
-          "Content-Type"   => "application/atom+xml",
-          "Content-Length" => "#{update_body.length}",
-        }
-        update_url = "/feeds/api/users/default/uploads/%s" % video_id
-        response   = yt_session.put(update_url, update_body, update_header)
+        @opts       = options
+        update_body = video_xml
+        update_url  = "/feeds/api/users/default/uploads/%s" % video_id
+        response    = yt_session.put(update_url, update_body)
         
         return YouTubeIt::Parser::VideoFeedParser.new(response.body).parse
       end
+      
+      # Fetches the currently authenticated user's contacts (i.e. friends).
+      # When the authentication credentials are incorrect, an AuthenticationError will be raised.
+      def get_my_contacts(opts)
+        contacts_url = "/feeds/api/users/default/contacts?v=2"
+        contacts_url << opts.collect { |k,p| [k,p].join '=' }.join('&')
+        response = yt_session.get(contacts_url)
+        
+        return YouTubeIt::Parser::ContactsParser.new(response).parse
+      end
 
       # Fetches the data of a video, which may be private. The video must be owned by this user.
       # When the authentication credentials are incorrect, an AuthenticationError will be raised.
       def get_my_video(video_id)
-        get_header = {
-                 "Content-Type"   => "application/atom+xml",
-                 "Content-Length" => "0",
-                 }
         get_url  = "/feeds/api/users/default/uploads/%s" % video_id
-        response = yt_session.get(get_url, get_header)
+        response = yt_session.get(get_url)
         
         return YouTubeIt::Parser::VideoFeedParser.new(response.body).parse
       end
@@ -118,51 +120,34 @@ class YouTubeIt
       def get_my_videos(opts)
         max_results = opts[:per_page] || 50
         start_index = ((opts[:page] || 1) -1) * max_results +1
-        get_header  = {
-                 "Content-Type"   => "application/atom+xml",
-                 "Content-Length" => "0",
-                 }
-        get_url  = "/feeds/api/users/default/uploads?max-results=#{max_results}&start-index=#{start_index}"
-        response = yt_session.get(get_url, get_header)
+        get_url     = "/feeds/api/users/default/uploads?max-results=#{max_results}&start-index=#{start_index}"
+        response    = yt_session.get(get_url)
 
         return YouTubeIt::Parser::VideosFeedParser.new(response.body).parse
       end
 
       # Delete a video on YouTube
       def delete(video_id)
-        delete_header = {
-          "Content-Type"   => "application/atom+xml; charset=UTF-8",
-          "Content-Length" => "0",
-        }
         delete_url = "/feeds/api/users/default/uploads/%s" % video_id
-        response = yt_session.delete(delete_url, delete_header)
+        response   = yt_session.delete(delete_url)
 
         return true
       end
 
       def get_upload_token(options, nexturl)
-        @opts         = options
-        token_body    = video_xml
-        token_header  = {
-          "Content-Type"   => "application/atom+xml; charset=UTF-8",
-          "Content-Length" => "#{token_body.length}",
-        }
-        token_url = "/action/GetUploadToken"
-        response = yt_session.post(token_url, token_body, token_header)
+        @opts      = options
+        token_body = video_xml
+        token_url  = "/action/GetUploadToken"
+        response   = yt_session.post(token_url, token_body)
         
         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  = {
-          "Content-Type"   => "application/atom+xml",
-          "Content-Length" => "#{comment_body.length}",
-        }
-        comment_url = "/feeds/api/videos/%s/comments" % video_id
-
-        response = yt_session.post(comment_url, comment_body, comment_header)
+        comment_body = video_xml_for(:comment => comment)
+        comment_url  = "/feeds/api/videos/%s/comments" % video_id
+        response     = yt_session.post(comment_url, comment_body)
         
         return {:code => response.status, :body => response.body}
       end
@@ -170,43 +155,44 @@ class YouTubeIt
       def comments(video_id, opts = {})
         comment_url = "/feeds/api/videos/%s/comments?" % video_id
         comment_url << opts.collect { |k,p| [k,p].join '=' }.join('&')
-        response = yt_session.get(comment_url)
+        response    = yt_session.get(comment_url)
         
         return YouTubeIt::Parser::CommentsFeedParser.new(response).parse
       end
 
       def add_favorite(video_id)
-        favorite_body   = video_xml_for(:favorite => video_id)
-        favorite_header = {
-          "Content-Type"   => "application/atom+xml",
-          "Content-Length" => "#{favorite_body.length}",
-        }
-        favorite_url = "/feeds/api/users/default/favorites"
-        response     = yt_session.post(favorite_url, favorite_body, favorite_header)
+        favorite_body = video_xml_for(:favorite => video_id)
+        favorite_url  = "/feeds/api/users/default/favorites"
+        response      = yt_session.post(favorite_url, favorite_body)
         
         return {:code => response.status, :body => response.body}
       end
 
       def delete_favorite(video_id)
         favorite_header = {
-          "Content-Type"   => "application/atom+xml; charset=UTF-8",
-          "Content-Length" => "0",
+          "GData-Version"  => "1",
         }
-        favorite_url    = "/feeds/api/users/default/favorites/%s" % video_id
-        response = yt_session.delete(favorite_url, favorite_header)
+        favorite_url = "/feeds/api/users/default/favorites/%s" % video_id
+        response     = yt_session.delete(favorite_url, favorite_header)
         
         return true
       end
 
       def profile(user)
-        profile_url    = "/feeds/api/users/%s?v=2" % (user ? user : "default")
-        profile_header = {
-          "Content-Type"   => "application/atom+xml; charset=UTF-8"
-        }
-        response = yt_session.get(profile_url, profile_header)
+        profile_url = "/feeds/api/users/%s?v=2" % (user ? user : "default")
+        response    = yt_session.get(profile_url)
 
         return YouTubeIt::Parser::ProfileFeedParser.new(response).parse
       end
+      
+      # Return's a user's activity feed.
+      def get_activity(user, opts)
+        activity_url = "/feeds/api/events?author=%s&v=2&" % (user ? user : "default")
+        activity_url << opts.collect { |k,p| [k,p].join '=' }.join('&')
+        response = yt_session.get(activity_url)
+        
+        return YouTubeIt::Parser::ActivityParser.new(response).parse
+      end
 
       def playlist(playlist_id)
         playlist_url = "/feeds/api/playlists/%s?v=2" % playlist_id
@@ -223,101 +209,69 @@ class YouTubeIt
       end
       
       def add_playlist(options)
-        playlist_body   = video_xml_for_playlist(options)
-        playlist_header = {
-          "Content-Type"   => "application/atom+xml",
-          "Content-Length" => "#{playlist_body.length}",
-        }
-        playlist_url = "/feeds/api/users/default/playlists"
-        response = yt_session.post(playlist_url, playlist_body, playlist_header)
+        playlist_body = video_xml_for_playlist(options)
+        playlist_url  = "/feeds/api/users/default/playlists"
+        response      = yt_session.post(playlist_url, playlist_body)
         
         return YouTubeIt::Parser::PlaylistFeedParser.new(response).parse
       end
 
       def add_video_to_playlist(playlist_id, video_id)
-        playlist_body   = video_xml_for(:playlist => video_id)
-        playlist_header = {
-          "Content-Type"   => "application/atom+xml",
-          "Content-Length" => "#{playlist_body.length}",
-        }
-        playlist_url = "/feeds/api/playlists/%s" % playlist_id
-        response = yt_session.post(playlist_url, playlist_body, playlist_header)
+        playlist_body = video_xml_for(:playlist => video_id)
+        playlist_url  = "/feeds/api/playlists/%s" % playlist_id
+        response      = yt_session.post(playlist_url, playlist_body)
         
         return {:code => response.status, :body => response.body, :playlist_entry_id => playlist_entry_id_from_playlist(response.body)}
       end
 
       def update_playlist(playlist_id, options)
-        playlist_body   = video_xml_for_playlist(options)
-        playlist_header = {
-          "Content-Type"   => "application/atom+xml",
-          "Content-Length" => "#{playlist_body.length}",
-        }
-        playlist_url = "/feeds/api/users/default/playlists/%s" % playlist_id
-        response = yt_session.put(playlist_url, playlist_body, playlist_header)
+        playlist_body = video_xml_for_playlist(options)
+        playlist_url  = "/feeds/api/users/default/playlists/%s" % playlist_id
+        response      = yt_session.put(playlist_url, playlist_body)
         
         return YouTubeIt::Parser::PlaylistFeedParser.new(response).parse
       end
 
       def delete_video_from_playlist(playlist_id, playlist_entry_id)
-        playlist_header = {
-          "Content-Type"   => "application/atom+xml",
-        }
         playlist_url = "/feeds/api/playlists/%s/%s" % [playlist_id, playlist_entry_id]
-        response = yt_session.delete(playlist_url, playlist_header)
+        response     = yt_session.delete(playlist_url)
         
         return true
       end
 
       def delete_playlist(playlist_id)
-        playlist_header  = {
-          "Content-Type" => "application/atom+xml; charset=UTF-8",
-        }
-        playlist_url     = "/feeds/api/users/default/playlists/%s" % playlist_id
-        response = yt_session.delete(playlist_url, playlist_header)
+        playlist_url = "/feeds/api/users/default/playlists/%s" % playlist_id
+        response     = yt_session.delete(playlist_url)
         
         return true
       end
 
       def rate_video(video_id, rating)
-        rating_body   = video_xml_for(:rating => rating)
-        rating_header = {
-          "Content-Type"   => "application/atom+xml",
-          "Content-Length" => "#{rating_body.length}",
-        }
-        rating_url = "/feeds/api/videos/#{video_id}/ratings"
-        response = yt_session.post(rating_url, rating_body, rating_header)
+        rating_body = video_xml_for(:rating => rating)
+        rating_url  = "/feeds/api/videos/#{video_id}/ratings"
+        response    = yt_session.post(rating_url, rating_body)
         
         return {:code => response.status, :body => response.body}
       end
       
       def subscriptions(user)
-        subscription_url    = "/feeds/api/users/%s/subscriptions?v=2" % (user ? user : "default")
-        subscription_header = {
-          "Content-Type"   => "application/atom+xml",
-        }
-        response = yt_session.get(subscription_url, subscription_header)
+        subscription_url = "/feeds/api/users/%s/subscriptions?v=2" % (user ? user : "default")
+        response         = yt_session.get(subscription_url)
         
         return YouTubeIt::Parser::SubscriptionFeedParser.new(response).parse
       end
             
       def subscribe_channel(channel_name)
-        subscribe_body   = video_xml_for(:subscribe => channel_name)
-        subscribe_header = {
-          "Content-Type"   => "application/atom+xml",
-          "Content-Length" => "#{subscribe_body.length}",
-        }
-        subscribe_url = "/feeds/api/users/default/subscriptions"
-        response = yt_session.post(subscribe_url, subscribe_body, subscribe_header)
+        subscribe_body = video_xml_for(:subscribe => channel_name)
+        subscribe_url  = "/feeds/api/users/default/subscriptions"
+        response       = yt_session.post(subscribe_url, subscribe_body)
          
         return {:code => response.status, :body => response.body}
       end
       
       def unsubscribe_channel(subscription_id)
-        unsubscribe_header = {
-          "Content-Type"   => "application/atom+xml"
-        }
         unsubscribe_url = "/feeds/api/users/default/subscriptions/%s" % subscription_id
-        response = yt_session.delete(unsubscribe_url, unsubscribe_header)
+        response        = yt_session.delete(unsubscribe_url)
            
         return {:code => response.status, :body => response.body}
       end
@@ -325,12 +279,13 @@ class YouTubeIt
       def favorites(user, opts = {})
         favorite_url = "/feeds/api/users/%s/favorites#{opts.empty? ? '' : '?#{opts.to_param}'}" % (user ? user : "default")
         response     = yt_session.get(favorite_url)
+
         return YouTubeIt::Parser::VideosFeedParser.new(response.body).parse
       end
 
       def get_current_user
         current_user_url = "/feeds/api/users/default"
-        response         = yt_session.get(current_user_url, authorization_headers)
+        response         = yt_session.get(current_user_url)
 
         return REXML::Document.new(response.body).elements["entry"].elements['author'].elements['name'].text
       end
@@ -350,14 +305,11 @@ class YouTubeIt
       end
 
       def authorization_headers
-        header = {
-                  "X-GData-Client" => "#{@client_id}",
-                  "X-GData-Key"    => "key=#{@dev_key}",
-                  "GData-Version" => "2",
-                }
+        header = {"X-GData-Client"  => "#{@client_id}"}
+        header.merge!("X-GData-Key" => "key=#{@dev_key}") if @dev_key
         if @authsub_token
           header.merge!("Authorization"  => "AuthSub token=#{@authsub_token}")
-        elsif @access_token.nil? && @authsub_token.nil?
+        elsif @access_token.nil? && @authsub_token.nil? && @user
           header.merge!("Authorization"  => "GoogleLogin auth=#{auth_token}")
         end
         header

data/lib/youtube_it.rb

@@ -61,6 +61,7 @@ end
   model/thumbnail
   model/user
   model/video
+  model/activity
   request/base_search
   request/error
   request/user_search

data/test/test_client.rb

@@ -234,16 +234,18 @@ class TestClient < Test::Unit::TestCase
     @client.video_delete(video.unique_id)
   end
   
+  
   def test_should_add_new_comment
-    video_id ="aDlw5j28X3U"
-    @client.add_comment(video_id, "test comment")
-    comment = @client.comments(video_id).first.content
+    video  = @client.video_upload(File.open("test/test.mov"), OPTIONS)
+    @client.add_comment(video.unique_id, "test comment")
+    comment = @client.comments(video.unique_id).first.content
     assert comment.match(/test comment/)
+    @client.video_delete(video.unique_id)
   end
-    
+       
   def test_should_add_and_delete_video_from_playlist
     playlist = @client.add_playlist(:title => "youtube_it test!", :description => "test playlist")
-    video = @client.add_video_to_playlist(playlist.playlist_id,"iKqJ8z1DPrQ")
+    video = @client.add_video_to_playlist(playlist.playlist_id,"CE62FSEoY28")
     assert_equal video[:code].to_i, 201
     assert @client.delete_video_from_playlist(playlist.playlist_id, video[:playlist_entry_id])
     assert @client.delete_playlist(playlist.playlist_id)
@@ -270,15 +272,15 @@ class TestClient < Test::Unit::TestCase
     
   def test_should_determine_if_widescreen_video_is_widescreen
    widescreen_id = 'QqQVll-MP3I'
-
+  
    video = @client.video_by(widescreen_id)
    assert video.widescreen?
   end
-
+  
   def test_get_current_user
    assert_equal @client.current_user, 'tubeit20101'
   end
-
+  
   def test_should_get_my_videos
    video  = @client.video_upload(File.open("test/test.mov"), OPTIONS)
    assert_valid_video video
@@ -286,7 +288,7 @@ class TestClient < Test::Unit::TestCase
    assert_equal result.videos.first.unique_id, video.unique_id
    @client.video_delete(video.unique_id)
   end
-
+  
   def test_should_get_my_video
    video  = @client.video_upload(File.open("test/test.mov"), OPTIONS)
    assert_valid_video video
@@ -294,33 +296,33 @@ class TestClient < Test::Unit::TestCase
    assert_equal result.unique_id, video.unique_id
    @client.video_delete(video.unique_id)
   end
-
+  
   def test_should_add_like_to_video
    r = @client.like_video("CE62FSEoY28")
    assert_equal r[:code], 201
    @client.dislike_video("CE62FSEoY28")
   end
-
+  
   def test_should_dislike_to_video
    @client.like_video("CE62FSEoY28")
    r = @client.dislike_video("CE62FSEoY28")
    assert_equal r[:code], 201
   end
-
-
+  
+  
   def test_should_subscribe_to_channel
    r = @client.subscribe_channel("TheWoWArthas")
    assert_equal r[:code], 201
    assert_equal @client.subscriptions.first.title, "Videos published by : TheWoWArthas"
    @client.unsubscribe_channel(@client.subscriptions.first.id)
   end
-
+  
   def test_should_unsubscribe_to_channel
    @client.subscribe_channel("TheWoWArthas")
    r = @client.unsubscribe_channel(@client.subscriptions.first.id)
    assert_equal r[:code], 200
   end
-
+  
   def test_should_list_subscriptions
    @client.subscribe_channel("TheWoWArthas")
    assert @client.subscriptions.count == 1
@@ -332,6 +334,15 @@ class TestClient < Test::Unit::TestCase
     profile = @client.profile
     assert_equal profile.username, "tubeit20101" 
   end
+  
+  def test_should_add_and_delete_video_to_favorite
+    video_id ="j5raG94IGCc"
+    result = @client.add_favorite(video_id)
+    assert_equal result[:code], 201
+    sleep 4
+    assert @client.delete_favorite(video_id)
+  end
+
   private
   
     def assert_valid_video (video)

data/test/test_video_feed_parser.rb

@@ -2,6 +2,14 @@ require File.expand_path(File.dirname(__FILE__) + '/helper')
 
 class TestVideoFeedParser < Test::Unit::TestCase
 
+  def test_should_raise_bad_request_exception_when_id_not_found
+    bad_url = "http://gdata.youtube.com/feeds/api/videos/abc?v=2"
+  
+    assert_raise(OpenURI::HTTPError) do
+      parser = YouTubeIt::Parser::VideoFeedParser.new bad_url
+    end
+  end
+
   # VIDEO ATTRIBUTES AFFECTED BY PARSING
 
   def test_should_display_unique_id_correctly_after_parsing
@@ -259,4 +267,5 @@ class TestVideoFeedParser < Test::Unit::TestCase
       yield parser
     end
   end
+    
 end

data/youtube_it.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{youtube_it}
-  s.version = "2.0.0"
+  s.version = "2.0.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["kylejginavan", "chebyte", "mseppae"]
-  s.date = %q{2011-07-02}
+  s.authors = [%q{kylejginavan}, %q{chebyte}, %q{mseppae}]
+  s.date = %q{2011-09-02}
   s.description = %q{Upload, delete, update, comment on youtube videos all from one gem.}
   s.email = %q{kylejginavan@gmail.com}
   s.extra_rdoc_files = [
@@ -26,6 +26,7 @@ Gem::Specification.new do |s|
     "lib/youtube_it/middleware/faraday_authheader.rb",
     "lib/youtube_it/middleware/faraday_oauth.rb",
     "lib/youtube_it/middleware/faraday_youtubeit.rb",
+    "lib/youtube_it/model/activity.rb",
     "lib/youtube_it/model/author.rb",
     "lib/youtube_it/model/category.rb",
     "lib/youtube_it/model/comment.rb",
@@ -60,8 +61,8 @@ Gem::Specification.new do |s|
     "youtube_it.gemspec"
   ]
   s.homepage = %q{http://github.com/kylejginavan/youtube_it}
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.5.2}
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.8}
   s.summary = %q{The most complete Ruby wrapper for youtube api's}
   s.test_files = [
     "test/helper.rb",

metadata

@@ -2,7 +2,7 @@
 name: youtube_it
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors: 
 - kylejginavan
@@ -12,8 +12,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-02 00:00:00 -05:00
-default_executable: 
+date: 2011-09-02 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: oauth
@@ -78,6 +77,7 @@ files:
 - lib/youtube_it/middleware/faraday_authheader.rb
 - lib/youtube_it/middleware/faraday_oauth.rb
 - lib/youtube_it/middleware/faraday_youtubeit.rb
+- lib/youtube_it/model/activity.rb
 - lib/youtube_it/model/author.rb
 - lib/youtube_it/model/category.rb
 - lib/youtube_it/model/comment.rb
@@ -110,7 +110,6 @@ files:
 - test/test_video_feed_parser.rb
 - test/test_video_search.rb
 - youtube_it.gemspec
-has_rdoc: true
 homepage: http://github.com/kylejginavan/youtube_it
 licenses: []
 
@@ -134,7 +133,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.5.2
+rubygems_version: 1.8.8
 signing_key: 
 specification_version: 3
 summary: The most complete Ruby wrapper for youtube api's