youtube_it 0.0.3 → 0.0.7

data/History.txt

@@ -1,52 +1,15 @@
-* Implement video update and video delete in Upload
-* Refactor the uploader slightly
-* Use Builder to generate XML packets
-* Use a faster Camping-based URL escaper (also avoid cgi.rb)
-* Removed the logger nightmare, use YouTubeIt.logger for everything whatever that may be
-* Use streams for file uploads instead of in-memory strings
+* Initial fork
 
-== 0.5.0 / 2009-01-07
+== 0.0.1 / 2010-07-05
 
-* Fixed bug in user favorites (thanks Pius Uzamere)
+* Enhanced youtube-g to support:
+  ~> direct uploads to youtube
+  ~> update video on youtube
+  ~> comment on youtube video
+  ~> delete youtube video
+  
+== 0.0.2 / 2010-07-07
 
-== 0.4.9.9 / 2008-09-01
-
-* Add Geodata information (thanks Jose Galisteo)
-* Added :page and :per_page options, this allows easier usage of the will_paginate
-  plugin with the library. The :offset and :max_results options are no longer available. [Daniel Insley]
-* Added ability to get video responses on the instances of the YouTube::Model::Video object. [Daniel Insley]
-* Added and improved the existing documentation [Daniel Insley]
-* Fixed usage of deprecated yt:racy, now using media:rating [Daniel Insley]
-* Renamed can_embed? method to embeddable? [Daniel Insley]
-* Added ability for padingation and ordering on standard feeds. [Daniel Insley]
-* Add error-handling for video upload errors. [FiXato]
-* Add error-handling for authentication errors from YouTube during video upload. [FiXato]
-* Add support for making videos private upon video upload. [FiXato]
-* Fix issue with REXML parsing of video upload response. [FiXato]
-* Fix issue with response code comparison. [FiXato]
-* Authcode is now retrieved for video uploads. [FiXato]
-* Add basic support for uploading videos [thanks Joe Damato]
-* Add basic support for related videos [tmm1]
-* Improve docs for order_by attribute [thanks Jason Arora]
-* Added support for the "racy" parameter (choices are "include" or "exclude") [thanks Jason Arora]
-* Add missing attribute reader for description [tmm1]
-* Fix issue with missing yt:statistics and viewCount [tmm1]
-* Allow Client#video_by to take either a url or a video id [tmm1]
-
-== 0.4.1 / 2008-02-11
-
-* Added 3GPP video format [shane]
-* Fixed tests [shane]
-
-== 0.4.0 / 2007-12-18
-
-* Fixed API projection in search URL [Pete Higgins]
-* Fixed embeddable video searching [Pete Higgins]
-* Fixed video embeddable detection [Pete Higgins]
-* Fixed unique id hyphen detection [Pete Higgins, Chris Taggart]
-
-== 0.3.0 / 2007-09-17
-
-* Initial public release
-  * Birthday!
+* ACL support
 
+== 0.0.3 / 2010-08-12

data/README.txt

@@ -1,6 +1,6 @@
 == DESCRIPTION:
 
-youtube_it is a pure Ruby client for the YouTube GData API. It provides an easy
+youtube_it is the most complete Ruby client for the YouTube GData API. It provides an easy
 way to access the latest YouTube video search results from your own programs.
 In comparison with the earlier Youtube search interfaces, this new API and
 library offers much-improved flexibility around executing complex search
@@ -42,6 +42,11 @@ Upload videos:
 
   client = YouTubeIt::Client.new("youtube_username", "youtube_passwd", "developer_key")
 
+  Or better yet, you can use OAuth
+
+  client = YouTubeIt::OAuthClient.new("consumer_key", "consumer_secret", "youtube_username", "developer_key")
+  client.authorize_from_access("access_token", "access_secret")
+
 * upload video
 
   client.video_upload(File.open("test.mov"), :title => "test",:description => 'some description', :category => 'People',:keywords => %w[cool blah test])
@@ -71,7 +76,7 @@ Comments
 
 Favorites
 
-  You can add, del or list your favorites videos:
+  You can add, delete or list your favorites videos:
 
   client = YouTubeIt::Client.new("youtube_username", "youtube_passwd", "developer_key")
 
@@ -83,9 +88,46 @@ Favorites
 
   client.add_favorite(video_id)
 
-*  del favorite:
+*  delete favorite:
+
+  client.delete_favorite(video_id)
+
+Playlist
+
+  You can add, delete or list your playlists:
+
+  client = YouTubeIt::Client.new("youtube_username", "youtube_passwd", "developer_key")
+
+*  get all playlists:
+
+  client.playlists
+
+*  select your playlist:
+
+  client.playlist(playlist_id)
+
+*  get all videos from your playlist:
+
+  my_playlist = client.playlist(playlist_id)
+
+  my_playlist.videos
+
+*  create new playlist:
+
+  my_playlist = client.add_playlist(:title => "new playlist", :description => "playlist description")
+
+*  delete a playlist:
+
+  client.delete_playlist(playlist_id)
+
+*  add video to playlist:
+
+  client.add_video_to_playlist(playlist_id, video_id)
+
+*  remove video from playlist:
+
+  client.remove_video_from_playlist(playlist_id, playlist_entry_id)
 
-  client.del_favorite(video_id)
 
 Access Control List
 
@@ -145,11 +187,12 @@ YouTubeIt passes all logs through the logger variable on the class itself. In Ra
 == INSTALL:
 
 * sudo gem install youtube_it
+
 == LICENSE:
 
 MIT License
 
-Copyright (c) 2007 Shane Vitarana and Walter Korman
+Copyright (c) 2010 Kyle J. Ginavan
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -5,11 +5,11 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "youtube_it"
-    gem.summary = %Q{the one stop shop for working with youtube apis}
-    gem.description = %Q{the one stop shop for working with youtube apis}
+    gem.summary = %Q{The most complete Ruby wrapper for youtube api's}
+    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.authors = ["Mauro Torres & Kyle Ginavan"]
+    gem.authors = ["chebyte","kylejginavan"]
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError
@@ -18,16 +18,16 @@ end
 
 require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|
-  test.libs << 'spec'
-  test.pattern = 'spec/**/*_spec.rb'
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
   test.verbose = true
 end
 
 begin
   require 'rcov/rcovtask'
   Rcov::RcovTask.new do |test|
-    test.libs << 'spec'
-    test.pattern = 'spec/**/*_spec.rb'
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
     test.verbose = true
   end
 rescue LoadError
@@ -50,10 +50,3 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-require 'spec/rake/spectask'
-desc "Run all specs"
-Spec::Rake::SpecTask.new('spec') do |t|
-  t.spec_opts = ['--colour --format progress --loadby mtime --reverse']
-  t.spec_files = FileList['spec/**/*_spec.rb']
-end
-

data/VERSION

@@ -1 +1,2 @@
-0.0.3
+0.0.7
+

data/lib/youtube_it/chain_io.rb

@@ -66,6 +66,11 @@ class YouTubeIt::GreedyChainIO < DelegateClass(YouTubeIt::ChainIO)
   def read(any_buffer_size)
     __getobj__.read(BIG_CHUNK)
   end
+
+  def length()
+    __getobj__.expected_length
+  end
+
 end
 
-#:startdoc:
+#:startdoc:

data/lib/youtube_it/client.rb

@@ -6,7 +6,6 @@ class YouTubeIt
       @user, @pass, @dev_key, @client_id = user, pass, dev_key, client_id
     end
 
-
     # Retrieves an array of standard feed, custom query, or user videos.
     #
     # === Parameters
@@ -107,14 +106,42 @@ class YouTubeIt
       client.add_favorite(video_id)
     end
 
-    def del_favorite(video_id)
-      client.del_favorite(video_id)
+    def delete_favorite(video_id)
+      client.delete_favorite(video_id)
     end
 
     def favorites
       client.favorites
     end
 
+    def playlist(playlist_id)
+      client.playlist playlist_id
+    end
+
+    def playlists
+      client.playlists
+    end
+
+    def add_playlist(options)
+      client.add_playlist(options)
+    end
+
+    def update_playlist(playlist_id, options)
+      client.update_playlist(playlist_id, options)
+    end
+
+    def add_video_to_playlist(playlist_id, video_id)
+      client.add_video_to_playlist(playlist_id, video_id)
+    end
+
+    def delete_video_from_playlist(playlist_id, playlist_entry_id)
+      client.delete_video_from_playlist(playlist_id, playlist_entry_id)
+    end
+
+    def delete_playlist(playlist_id)
+      client.delete_playlist(playlist_id)
+    end
+
     def enable_http_debugging
       client.enable_http_debugging
     end
@@ -134,5 +161,45 @@ class YouTubeIt
       value > 0 ? value : default
     end
   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
+    end
+
+    def consumer
+      @consumer ||= OAuth::Consumer.new(@consumer_key,@consumer_secret,{
+        :site=>"https://www.google.com",
+        :request_token_path=>"/accounts/OAuthGetRequestToken",
+        :authorize_path=>"/accounts/OAuthAuthorizeToken",
+        :access_token_path=>"/accounts/OAuthGetAccessToken"})
+    end
+
+    def request_token(callback)
+      @request_token = consumer.get_request_token({:oauth_callback => callback},{:scope => "http://gdata.youtube.com"})
+    end
+
+    def access_token
+      @access_token = OAuth::AccessToken.new(consumer, @atoken, @asecret)
+    end
+
+    def authorize_from_request(rtoken,rsecret,verifier)
+      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
+
+    def authorize_from_access(atoken,asecret)
+      @atoken,@asecret = atoken, asecret
+    end
+
+    private
+
+    def client
+      # IMPORTANT: make sure authorize_from_access is called before client is fetched
+      @client ||= YouTubeIt::Upload::VideoUpload.new(@user, "", @dev_key, "youtube_it", access_token)
+    end
+
+  end
 end
 

data/lib/youtube_it/model/playlist.rb

@@ -1,8 +1,11 @@
 class YouTubeIt
   module Model
     class Playlist < YouTubeIt::Record
-      # *String*:: User entered description for the playlist.
-      attr_reader :description
+      attr_reader :title, :description, :summary, :playlist_id, :xml, :published, :response_code
+      def videos
+        YouTubeIt::Parser::VideosFeedParser.new("http://gdata.youtube.com/feeds/api/playlists/#{playlist_id}?v=2").parse_videos
+      end
     end
   end
 end
+

data/lib/youtube_it/parser.rb

@@ -1,12 +1,37 @@
 class YouTubeIt
   module Parser #:nodoc:
     class FeedParser #:nodoc:
-      def initialize(url)
-        @url = open(url).read rescue url
+      def initialize(content)
+        @content = open(content).read rescue content
       end
 
       def parse
-        parse_content @url
+        parse_content @content
+      end
+
+      def parse_videos
+        doc = REXML::Document.new(@content)
+        videos = []
+        doc.elements.each("*/entry") do |video|
+          videos << parse_entry(video)
+        end
+        videos
+      end
+    end
+
+    class PlaylistFeedParser < FeedParser #:nodoc:
+
+      def parse_content(content)
+        xml = REXML::Document.new(content.body)
+        entry = xml.elements["entry"] || xml.elements["feed"]
+        YouTubeIt::Model::Playlist.new(
+          :title         => entry.elements["title"].text,
+          :summary       => (entry.elements["summary"] || entry.elements["media:group"].elements["media:description"]).text,
+          :description   => (entry.elements["summary"] || entry.elements["media:group"].elements["media:description"]).text,
+          :playlist_id   => entry.elements["id"].text[/playlist([^<]+)/, 1].sub(':',''),
+          :published     => entry.elements["published"] ? entry.elements["published"].text : nil,
+          :response_code => content.code,
+          :xml           => content.body)
       end
     end
 
@@ -21,8 +46,8 @@ class YouTubeIt
     protected
       def parse_entry(entry)
         video_id = entry.elements["id"].text
-        published_at = Time.parse(entry.elements["published"].text)
-        updated_at = Time.parse(entry.elements["updated"].text)
+        published_at  = entry.elements["published"] ? Time.parse(entry.elements["published"].text) : nil
+        updated_at    = entry.elements["updated"] ? Time.parse(entry.elements["updated"].text) : nil
 
         # parse the category and keyword lists
         categories = []
@@ -43,7 +68,7 @@ class YouTubeIt
         end
 
         title = entry.elements["title"].text
-        html_content = entry.elements["content"].text
+        html_content = entry.elements["content"] ? entry.elements["content"].text : nil
 
         # parse the author
         author_element = entry.elements["author"]

data/lib/youtube_it/request/video_upload.rb

@@ -16,8 +16,8 @@ class YouTubeIt
     #
     class VideoUpload
       include YouTubeIt::Logging
-      def initialize user, pass, dev_key, client_id = 'youtube_it'
-        @user, @pass, @dev_key, @client_id = user, pass, dev_key, client_id
+      def initialize user, pass, dev_key, client_id = 'youtube_it', access_token = nil
+        @user, @pass, @dev_key, @client_id, @access_token = user, pass, dev_key, client_id, access_token
         @http_debugging = false
       end
 
@@ -52,6 +52,7 @@ class YouTubeIt
       #
       # When the authentication credentials are incorrect, an AuthenticationError will be raised.
       def upload data, opts = {}
+        response = ""
         @opts = { :mime_type => 'video/mp4',
                   :title => '',
                   :description => '',
@@ -62,28 +63,31 @@ class YouTubeIt
 
         post_body_io = generate_upload_io(video_xml, data)
 
-        upload_headers = authorization_headers.merge({
+        upload_headers = {
             "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
-        })
-
-        path = '/feeds/api/users/%s/uploads' % @user
-
-        http = Net::HTTP.new(uploads_url)
-        http.set_debug_output(logger) if @http_debugging
-        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.body_stream = post_body_io
-
-          response = session.request(post)
-          raise_on_faulty_response(response)
+        }
 
-          return uploaded_video_id_from(response.body)
+        if @access_token.nil?
+          upload_headers.merge!(authorization_headers)
+          http = Net::HTTP.new(uploads_url)
+          http.set_debug_output(logger) if @http_debugging
+          path = '/feeds/api/users/%s/uploads' % @user
+          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.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)
         end
+        raise_on_faulty_response(response)
+        return YouTubeIt::Parser::VideoFeedParser.new(response.body).parse
       end
 
       # Updates a video in YouTube.  Requires:
@@ -95,42 +99,55 @@ class YouTubeIt
       #   :private
       # When the authentication credentials are incorrect, an AuthenticationError will be raised.
       def update(video_id, options)
+        response = ""
         @opts = options
 
         update_body = video_xml
 
-        update_header = authorization_headers.merge({
+        update_header = {
           "GData-Version" => "2",
           "Content-Type"   => "application/atom+xml",
           "Content-Length" => "#{update_body.length}",
-        })
+        }
 
         update_url = "/feeds/api/users/#{@user}/uploads/#{video_id}"
 
-        http = Net::HTTP.new(base_url)
-        http.set_debug_output(logger) if @http_debugging
-        http.start do | session |
-          response = session.put(update_url, update_body, update_header)
-          raise_on_faulty_response(response)
-
-          return YouTubeIt::Parser::VideoFeedParser.new(response.body).parse
+        if @access_token.nil?
+          update_header.merge!(authorization_headers)
+          http_connection do |session|
+            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)
         end
+
+        raise_on_faulty_response(response)
+        return YouTubeIt::Parser::VideoFeedParser.new(response.body).parse
       end
 
       # Delete a video on YouTube
       def delete(video_id)
-        delete_header = authorization_headers.merge({
+        delete_header = {
           "Content-Type"   => "application/atom+xml; charset=UTF-8",
           "Content-Length" => "0",
-        })
+        }
 
         delete_url = "/feeds/api/users/#{@user}/uploads/#{video_id}"
 
-        Net::HTTP.start(base_url) do |session|
-          response = session.delete(delete_url, delete_header)
+        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)
-          return true
         end
+
+        return true
       end
 
       def get_upload_token(options, nexturl)
@@ -143,7 +160,7 @@ class YouTubeIt
         })
         token_url = "/action/GetUploadToken"
 
-        Net::HTTP.start(base_url) do | session |
+        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}",
@@ -161,23 +178,19 @@ class YouTubeIt
 
         comment_url = "/feeds/api/videos/#{video_id}/comments"
 
-        http = Net::HTTP.new(base_url)
-        http.set_debug_output(logger) if @http_debugging
-        http.start do | session |
+        http_connection do |session|
           response = session.post(comment_url, comment_body, comment_header)
           raise_on_faulty_response(response)
-          response = {:code => response.code, :body => response.body}
+          {:code => response.code, :body => response.body}
         end
       end
 
       def comments(video_id)
         comment_url = "/feeds/api/videos/#{video_id}/comments"
-        http = Net::HTTP.new(base_url)
-        http.set_debug_output(logger) if @http_debugging
-        http.start do | session |
+        http_connection do |session|
           response = session.get(comment_url)
           raise_on_faulty_response(response)
-          response = {:code => response.code, :body => response.body}
+          {:code => response.code, :body => response.body}
         end
       end
 
@@ -191,16 +204,14 @@ class YouTubeIt
 
         favorite_url = "/feeds/api/users/#{@user}/favorites"
 
-        http = Net::HTTP.new(base_url)
-        http.set_debug_output(logger) if @http_debugging
-        http.start do | session |
+        http_connection do |session|
           response = session.post(favorite_url, favorite_body, favorite_header)
           raise_on_faulty_response(response)
-          return true
+          {:code => response.code, :body => response.body}
         end
       end
 
-      def del_favorite(video_id)
+      def delete_favorite(video_id)
         favorite_header = authorization_headers.merge({
           "Content-Type"   => "application/atom+xml; charset=UTF-8",
           "Content-Length" => "0",
@@ -208,20 +219,116 @@ class YouTubeIt
 
         favorite_url = "/feeds/api/users/#{@user}/favorites/#{video_id}"
 
-        http = Net::HTTP.new(base_url)
-        http.set_debug_output(logger) if @http_debugging
-        http.start do | session |
+        http_connection do |session|
           response = session.delete(favorite_url, favorite_header)
           raise_on_faulty_response(response)
           return true
         end
       end
 
+      def playlist(playlist_id)
+        playlist_url = "/feeds/api/playlists/#{playlist_id}?v=2"
+        http_connection do |session|
+          response = session.get(playlist_url)
+          raise_on_faulty_response(response)
+          return YouTubeIt::Parser::PlaylistFeedParser.new(response).parse
+        end
+      end
+
+      def playlists
+        playlist_url = "/feeds/api/users/#{@user}/playlists?v=2"
+        http_connection do |session|
+          response = session.get(playlist_url)
+          raise_on_faulty_response(response)
+          return response.body
+        end
+      end
+
+      def add_playlist(options)
+        playlist_body   = video_xml_for_playlist(options)
+        playlist_header = authorization_headers.merge({
+          "GData-Version" => "2",
+          "Content-Type"   => "application/atom+xml",
+          "Content-Length" => "#{playlist_body.length}",
+        })
+
+        playlist_url = "/feeds/api/users/#{@user}/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
+        end
+      end
+
+      def add_video_to_playlist(playlist_id, video_id)
+        playlist_body   = video_xml_for(:playlist => video_id)
+        playlist_header = authorization_headers.merge({
+          "GData-Version" => "2",
+          "Content-Type"   => "application/atom+xml",
+          "Content-Length" => "#{playlist_body.length}",
+        })
+
+        playlist_url = "/feeds/api/playlists/#{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)}
+        end
+      end
+
+      def update_playlist(playlist_id, options)
+        playlist_body   = video_xml_for_playlist(options)
+        playlist_header = authorization_headers.merge({
+          "GData-Version" => "2",
+          "Content-Type"   => "application/atom+xml",
+          "Content-Length" => "#{playlist_body.length}",
+        })
+        playlist_url = "/feeds/api/users/#{@user}/playlists/#{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
+        end
+      end
+
+
+      def delete_video_from_playlist(playlist_id, playlist_entry_id)
+        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/#{playlist_id}/#{playlist_entry_id}"
+
+        http_connection do |session|
+          response = session.delete(playlist_url, playlist_header)
+          raise_on_faulty_response(response)
+          return true
+        end
+      end
+
+      def delete_playlist(playlist_id)
+        playlist_header = authorization_headers.merge({
+          "Content-Type"   => "application/atom+xml; charset=UTF-8",
+          "GData-Version" => "2"
+        })
+
+        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
+        end
+      end
+
       def favorites
         favorite_url = "/feeds/api/users/#{@user}/favorites"
-        http = Net::HTTP.new(base_url)
-        http.set_debug_output(logger) if @http_debugging
-        http.start do | session |
+        http_connection do |session|
           response = session.get(favorite_url)
           raise_on_faulty_response(response)
           return response.body
@@ -242,6 +349,12 @@ class YouTubeIt
         "An43094fu"
       end
 
+      def authorization_headers_for_soap
+        {
+          "X-GData-Key"    => "key=#{@dev_key}"
+        }
+      end
+
       def authorization_headers
         {
           "Authorization"  => "GoogleLogin auth=#{auth_token}",
@@ -251,10 +364,18 @@ class YouTubeIt
       end
 
       def parse_upload_error_from(string)
-        REXML::Document.new(string).elements["//errors"].inject('') do | all_faults, error|
-          location = error.elements["location"].text[/media:group\/media:(.*)\/text\(\)/,1]
-          code = error.elements["code"].text
-          all_faults + sprintf("%s: %s\n", location, code)
+        begin
+          REXML::Document.new(string).elements["//errors"].inject('') do | all_faults, error|
+            if error.elements["internalReason"]
+              msg_error = error.elements["internalReason"].text
+            elsif error.elements["location"]
+              msg_error = error.elements["location"].text[/media:group\/media:(.*)\/text\(\)/,1]
+            end
+            code = error.elements["code"].text if error.elements["code"]
+            all_faults + sprintf("%s: %s\n", msg_error, code)
+          end
+        rescue
+          string
         end
       end
 
@@ -262,7 +383,7 @@ class YouTubeIt
         if response.code.to_i == 403
           raise AuthenticationError, response.body[/<TITLE>(.+)<\/TITLE>/, 1]
         elsif response.code.to_i / 10 != 20 # Response in 20x means success
-          raise UploadError, parse_upload_error_from(response.body)
+          raise UploadError, parse_upload_error_from(response.body.gsub(/\n/,''))
         end
       end
 
@@ -271,6 +392,12 @@ class YouTubeIt
         xml.elements["//id"].text[/videos\/(.+)/, 1]
       end
 
+      def playlist_id_from(string)
+        xml = REXML::Document.new(string)
+        entry = xml.elements["entry"]
+        entry.elements["id"].text[/playlist([^<]+)/, 1].sub(':','')
+      end
+
       # If data can be read, use the first 1024 bytes as filename. If data
       # is a file, use path. If data is a string, checksum it
       def generate_uniq_filename_from(data)
@@ -323,15 +450,17 @@ class YouTubeIt
         b.instruct!
         b.entry(:xmlns => "http://www.w3.org/2005/Atom", 'xmlns:yt' => "http://gdata.youtube.com/schemas/2007") do | m |
           m.content(data[:comment]) if data[:comment]
-          m.id(data[:favorite]) if data[:favorite]
+          m.id(data[:favorite] || data[:playlist]) if data[:favorite] || data[:playlist]
         end.to_s
       end
 
-      def video_xml_for_favorite(video_id)
+      def video_xml_for_playlist(data)
         b = Builder::XmlMarkup.new
         b.instruct!
         b.entry(:xmlns => "http://www.w3.org/2005/Atom", 'xmlns:yt' => "http://gdata.youtube.com/schemas/2007") do | m |
-          m.id(video_id)
+          m.title(data[:title]) if data[:title]
+          m.summary(data[:description] || data[:summary]) if data[:description] || data[:summary]
+          m.tag!('yt:private') if data[:private]
         end.to_s
       end
 
@@ -350,6 +479,20 @@ class YouTubeIt
         YouTubeIt::GreedyChainIO.new(post_body)
       end
 
+      def playlist_entry_id_from_playlist(string)
+        playlist_xml = REXML::Document.new(string)
+        playlist_xml.elements.each("/entry") do |item|
+          return item.elements["id"].text[/^.*:([^:]+)$/,1]
+        end
+      end
+
+      def http_connection
+        http = Net::HTTP.new(base_url)
+        http.set_debug_output(logger) if @http_debugging
+        http.start do |session|
+          yield(session)
+        end
+      end
     end
   end
 end

data/test/test_client.rb

@@ -45,7 +45,7 @@ class TestClient < Test::Unit::TestCase
     assert_equal 25, response.max_result_count
     assert_equal 1, response.offset
 
-    response = @client.videos_by(:query => "penguin", :page => 2)
+      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
@@ -145,13 +145,13 @@ class TestClient < Test::Unit::TestCase
 
   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\"></param>\n  <param name=\"wmode\" value=\"transparent\"></param>\n  <embed src=\"http://www.youtube.com/v/EkF4JD2rO3Q&feature=youtube_gdata\" type=\"application/x-shockwave-flash\" \n   wmode=\"transparent\" width=\"425\" height=\"350\"></embed>\n</object>\n", video.embed_html
+    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\"></param>\n  <param name=\"wmode\" value=\"transparent\"></param>\n  <embed src=\"http://www.youtube.com/v/FQK1URcxmb4&feature=youtube_gdata\" type=\"application/x-shockwave-flash\" \n   wmode=\"transparent\" width=\"425\" height=\"350\"></embed>\n</object>\n", video.embed_html
+    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
 
@@ -190,51 +190,45 @@ class TestClient < Test::Unit::TestCase
   end
 
   def test_should_upload_a_video
-    video_id  = @client.video_upload(File.open("test/test.mov"), OPTIONS)
-    video     = @client.video_by_user(ACCOUNT[:user], video_id)
+    video  = @client.video_upload(File.open("test/test.mov"), OPTIONS)
     assert_valid_video video
-    @client.video_delete(video_id)
+    @client.video_delete(video.unique_id)
   end
 
   def test_should_update_a_video
     OPTIONS[:title] = "title changed"
-    @client.video_update("BhTw20Lr4v8", OPTIONS)
-    video  = @client.video_by("BhTw20Lr4v8")
+    video  = @client.video_update("iKqJ8z1DPrQ", OPTIONS)
     assert video.title == "title changed"
-    OPTIONS[:title] = "maddie"
-    @client.video_update("BhTw20Lr4v8", OPTIONS)
+    OPTIONS[:title] = "test rails"
+    @client.video_update("iKqJ8z1DPrQ", OPTIONS)
   end
 
   def test_should_delete_video
-    video_id  = @client.video_upload(File.open("test/test.mov"), OPTIONS)
-    video     = @client.video_by_user(ACCOUNT[:user], video_id)
+    video  = @client.video_upload(File.open("test/test.mov"), OPTIONS)
     assert_valid_video video
-    assert @client.video_delete(video_id)
+    assert @client.video_delete(video.unique_id)
   end
 
   def test_should_denied_comments
-    video_id  = @client.video_upload(File.open("test/test.mov"), OPTIONS.merge(:comment => "denied"))
-    video     = @client.video_by_user(ACCOUNT[:user], video_id)
+    video     = @client.video_upload(File.open("test/test.mov"), OPTIONS.merge(:comment => "denied"))
     assert_valid_video video
-    doc = Nokogiri::HTML(open("http://www.youtube.com/watch?v=#{video_id}"))
+    doc = Nokogiri::HTML(open("http://www.youtube.com/watch?v=#{video.unique_id}"))
     doc.css('.comments-disabled').each{|tag| assert (tag.content.strip == "Adding comments has been disabled for this video.")}
-    @client.video_delete(video_id)
+    @client.video_delete(video.unique_id)
   end
 
   def test_should_denied_rate
-    video_id  = @client.video_upload(File.open("test/test.mov"), OPTIONS.merge(:rate => "denied"))
-    video     = @client.video_by_user(ACCOUNT[:user], video_id)
+    video  = @client.video_upload(File.open("test/test.mov"), OPTIONS.merge(:rate => "denied"))
     assert_valid_video video
-    doc = Nokogiri::HTML(open("http://www.youtube.com/watch?v=#{video_id}"))
+    doc = Nokogiri::HTML(open("http://www.youtube.com/watch?v=#{video.unique_id}"))
     doc.css('#watch-like').each{|tag|; assert (tag.attributes["title"].to_s == "Ratings have been disabled for this video.")}
-    @client.video_delete(video_id)
+    @client.video_delete(video.unique_id)
   end
 
   def test_should_denied_embed
-    video_id  = @client.video_upload(File.open("test/test.mov"), OPTIONS.merge(:embed => "denied"))
-    video     = @client.video_by_user(ACCOUNT[:user], video_id)
+    video  = @client.video_upload(File.open("test/test.mov"), OPTIONS.merge(:embed => "denied"))
     assert    video.noembed
-    @client.video_delete(video_id)
+    @client.video_delete(video.unique_id)
   end
 
   def test_should_add_new_comment
@@ -244,10 +238,33 @@ class TestClient < Test::Unit::TestCase
     assert comment.match(/test comment/)
   end
 
-  def test_shoul_add_and_del_video_to_favorite
+  def test_shoul_add_and_delete_video_to_favorite
     video_id ="H1TrfM3xbgc"
-    assert @client.add_favorite(video_id)
-    assert @client.del_favorite(video_id)
+    result = @client.add_favorite(video_id)
+    assert result[:code], 201
+    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")
+    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)
+  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!"
+    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
 
   private
@@ -297,7 +314,7 @@ class TestClient < Test::Unit::TestCase
 
       assert_instance_of Time, video.updated_at
       # http://gdata.youtube.com/feeds/videos/IHVaXG1thXM
-      assert_valid_url video.video_id
+      assert_valid_url video.unique_id
       assert_instance_of Fixnum, video.view_count
       assert_instance_of Fixnum, video.favorite_count
 

data/test/test_video.rb

@@ -22,17 +22,18 @@ class TestVideo < Test::Unit::TestCase
     assert(response.total_result_count > 0)
     assert_instance_of Time, response.updated_at
   end
-  
+
   def test_should_have_response_videos
     video = YouTubeIt::Model::Video.new(:video_id => "http://gdata.youtube.com/feeds/videos/BDqs-OZWw9o")
     response = video.responses
 
     assert_equal "http://gdata.youtube.com/feeds/api/videos/BDqs-OZWw9o/responses", response.feed_id
     assert_equal 25, response.max_result_count
-    assert_equal 25, response.videos.length
+    assert_equal 24, response.videos.length
     assert_equal 1, response.offset
     assert(response.total_result_count > 0)
     assert_instance_of Time, response.updated_at
   end
-  
+
 end
+

data/youtube_it.gemspec

@@ -5,12 +5,12 @@
 
 Gem::Specification.new do |s|
   s.name = %q{youtube_it}
-  s.version = "0.0.3"
+  s.version = "0.0.7"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Mauro Torres & Kyle Ginavan"]
-  s.date = %q{2010-08-12}
-  s.description = %q{the one stop shop for working with youtube apis}
+  s.authors = ["chebyte", "kylejginavan"]
+  s.date = %q{2010-10-18}
+  s.description = %q{Upload, delete, update, comment on youtube videos all from one gem.}
   s.email = %q{kylejginavan@gmail.com}
   s.extra_rdoc_files = [
     "README.txt"
@@ -43,23 +43,19 @@ 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.1.gem",
-     "pkg/youtube_it-0.0.2.gem",
-     "pkg/youtube_it-0.0.3.gem",
      "test/helper.rb",
      "test/test.mov",
      "test/test_chain_io.rb",
      "test/test_client.rb",
      "test/test_video.rb",
      "test/test_video_search.rb",
-     "youtube_it.gemspec",
-     "youtube_it.tmproj"
+     "youtube_it.gemspec"
   ]
   s.homepage = %q{http://github.com/kylejginavan/youtube_it}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.6}
-  s.summary = %q{the one stop shop for working with youtube apis}
+  s.summary = %q{The most complete Ruby wrapper for youtube api's}
   s.test_files = [
     "test/helper.rb",
      "test/test_chain_io.rb",

metadata

@@ -5,20 +5,21 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 7
+  version: 0.0.7
 platform: ruby
 authors: 
-- Mauro Torres & Kyle Ginavan
+- chebyte
+- kylejginavan
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-08-12 00:00:00 -05:00
+date: 2010-10-18 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
-description: the one stop shop for working with youtube apis
+description: Upload, delete, update, comment on youtube videos all from one gem.
 email: kylejginavan@gmail.com
 executables: []
 
@@ -54,9 +55,6 @@ 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.1.gem
-- pkg/youtube_it-0.0.2.gem
-- pkg/youtube_it-0.0.3.gem
 - test/helper.rb
 - test/test.mov
 - test/test_chain_io.rb
@@ -64,7 +62,6 @@ files:
 - test/test_video.rb
 - test/test_video_search.rb
 - youtube_it.gemspec
-- youtube_it.tmproj
 has_rdoc: true
 homepage: http://github.com/kylejginavan/youtube_it
 licenses: []
@@ -94,7 +91,7 @@ rubyforge_project:
 rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: the one stop shop for working with youtube apis
+summary: The most complete Ruby wrapper for youtube api's
 test_files: 
 - test/helper.rb
 - test/test_chain_io.rb

data/youtube_it.tmproj

@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>documents</key>
-	<array>
-		<dict>
-			<key>expanded</key>
-			<true/>
-			<key>name</key>
-			<string>youtube_it</string>
-			<key>regexFolderFilter</key>
-			<string>!.*/(\.[^/]*|CVS|_darcs|_MTN|\{arch\}|blib|.*~\.nib|.*\.(framework|app|pbproj|pbxproj|xcode(proj)?|bundle))$</string>
-			<key>sourceDirectory</key>
-			<string></string>
-		</dict>
-	</array>
-	<key>fileHierarchyDrawerWidth</key>
-	<integer>200</integer>
-	<key>metaData</key>
-	<dict/>
-	<key>showFileHierarchyDrawer</key>
-	<true/>
-	<key>windowFrame</key>
-	<string>{{1769, 105}, {1144, 1070}}</string>
-</dict>
-</plist>