tmm1-youtube-g 0.5.0 → 0.5.1

data/History.txt

@@ -1,3 +1,14 @@
+* 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 YouTubeG.logger for everything whatever that may be
+* Use streams for file uploads instead of in-memory strings
+
+== 0.5.0 / 2009-01-07
+
+* Fixed bug in user favorites (thanks Pius Uzamere)
+
 == 0.4.9.9 / 2008-09-01
 
 * Add Geodata information (thanks Jose Galisteo)

data/Manifest.txt

@@ -4,8 +4,8 @@ README.txt
 Rakefile
 TODO.txt
 lib/youtube_g.rb
+lib/youtube_g/chain_io.rb
 lib/youtube_g/client.rb
-lib/youtube_g/logger.rb
 lib/youtube_g/model/author.rb
 lib/youtube_g/model/category.rb
 lib/youtube_g/model/contact.rb
@@ -23,6 +23,9 @@ lib/youtube_g/request/user_search.rb
 lib/youtube_g/request/video_search.rb
 lib/youtube_g/request/video_upload.rb
 lib/youtube_g/response/video_search.rb
+lib/youtube_g/version.rb
+test/helper.rb
+test/test_chain_io.rb
 test/test_client.rb
 test/test_video.rb
 test/test_video_search.rb

data/README.txt

@@ -1,9 +1,6 @@
-youtube-g
-    by Shane Vitarana and Walter Korman
+= youtube-g
 
-  Rubyforge: http://rubyforge.org/projects/youtube-g/
-  RDoc: http://youtube-g.rubyforge.org/
-  Google Group: http://groups.google.com/group/ruby-youtube-library
+http://youtube-g.rubyforge.org/
 
 == DESCRIPTION:
 
@@ -17,6 +14,15 @@ More detail on the underlying source Google-provided API is available at:
 
 http://code.google.com/apis/youtube/overview.html
 
+== AUTHORS
+
+Shane Vitarana and Walter Korman
+
+== WHERE TO GET HELP
+
+http://rubyforge.org/projects/youtube-g
+http://groups.google.com/group/ruby-youtube-library
+  
 == FEATURES/PROBLEMS:
   
 * Aims to be in parity with Google's YouTube GData API.  Core functionality
@@ -49,10 +55,17 @@ Advanced queries (with boolean operators OR (either), AND (include), NOT (exclud
 	
   client.videos_by(:categories => { :either => [:news, :sports], :exclude => [:comedy] }, :tags => { :include => ['football'], :exclude => ['soccer'] })
 
+== LOGGING
+
+YouTubeG 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
+(don't forget to set the level to debug):
+
+ YouTubeG.logger = RAILS_DEFAULT_LOGGER
+ RAILS_DEFAULT_LOGGER.level = Logger::DEBUG
 
 == REQUIREMENTS:
 
-* None
+* builder gem
 
 == INSTALL:
 

data/Rakefile

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'hoe'
+require 'lib/youtube_g/version'
+
+Hoe.new('youtube-g', YouTubeG::VERSION) do |p|
+  p.rubyforge_name = 'youtube-g'
+  p.author = ["Shane Vitarana", "Walter Korman", "Aman Gupta", "Filip H.F. Slagter", "msp"]
+  p.email = 'shanev@gmail.com'
+  p.summary = 'Ruby client for the YouTube GData API'
+  p.url = 'http://rubyforge.org/projects/youtube-g/'
+  p.extra_deps << 'builder'
+  p.remote_rdoc_dir = ''
+end
+
+desc 'Tag release'
+task :tag do
+  svn_root = 'svn+ssh://drummr77@rubyforge.org/var/svn/youtube-g'
+  sh %(svn cp #{svn_root}/trunk #{svn_root}/tags/release-#{YouTubeG::VERSION} -m "Tag YouTubeG release #{YouTubeG::VERSION}")
+end
+
+desc 'Load the library in an IRB session'
+task :console do
+  sh %(irb -r lib/youtube_g.rb)
+end

data/lib/youtube_g.rb

@@ -3,27 +3,65 @@ require 'open-uri'
 require 'net/https'
 require 'digest/md5'
 require 'rexml/document'
-require 'cgi'
+require 'builder'
 
-require File.dirname(__FILE__) + '/youtube_g/client'
-require File.dirname(__FILE__) + '/youtube_g/record'
-require File.dirname(__FILE__) + '/youtube_g/parser'
-require File.dirname(__FILE__) + '/youtube_g/model/author'
-require File.dirname(__FILE__) + '/youtube_g/model/category'
-require File.dirname(__FILE__) + '/youtube_g/model/contact'
-require File.dirname(__FILE__) + '/youtube_g/model/content'
-require File.dirname(__FILE__) + '/youtube_g/model/playlist'
-require File.dirname(__FILE__) + '/youtube_g/model/rating'
-require File.dirname(__FILE__) + '/youtube_g/model/thumbnail'
-require File.dirname(__FILE__) + '/youtube_g/model/user'
-require File.dirname(__FILE__) + '/youtube_g/model/video'
-require File.dirname(__FILE__) + '/youtube_g/request/base_search'
-require File.dirname(__FILE__) + '/youtube_g/request/user_search'
-require File.dirname(__FILE__) + '/youtube_g/request/standard_search'
-require File.dirname(__FILE__) + '/youtube_g/request/video_upload'
-require File.dirname(__FILE__) + '/youtube_g/request/video_search'
-require File.dirname(__FILE__) + '/youtube_g/response/video_search'
+class YouTubeG
+  
+  # Base error class for the extension
+  class Error < RuntimeError
+  end
+  
+  # URL-escape a string. Stolen from Camping (wonder how many Ruby libs in the wild can say the same)
+  def self.esc(s) #:nodoc:
+    s.to_s.gsub(/[^ \w.-]+/n){'%'+($&.unpack('H2'*$&.size)*'%').upcase}.tr(' ', '+')
+  end
+  
+  # Set the logger for the library
+  def self.logger=(any_logger)
+    @logger = any_logger
+  end
 
-class YouTubeG #:nodoc:
-  VERSION = '0.5.0'
+  # Get the logger for the library (by default will log to STDOUT). TODO: this is where we grab the Rails logger too
+  def self.logger
+    @logger ||= create_default_logger
+  end
+  
+  # Gets mixed into the classes to provide the logger method
+  module Logging #:nodoc:
+    
+    # Return the base logger set for the library
+    def logger
+      YouTubeG.logger
+    end
+  end
+    
+  private
+    def self.create_default_logger
+      logger = Logger.new(STDOUT)
+      logger.level = Logger::DEBUG
+      logger
+    end
 end
+
+%w( 
+  version
+  client
+  record
+  parser
+  model/author
+  model/category
+  model/contact
+  model/content
+  model/playlist
+  model/rating
+  model/thumbnail
+  model/user
+  model/video
+  request/base_search
+  request/user_search
+  request/standard_search
+  request/video_upload
+  request/video_search
+  response/video_search
+  chain_io
+).each{|m| require File.dirname(__FILE__) + '/youtube_g/' + m }

data/lib/youtube_g/chain_io.rb

@@ -0,0 +1,71 @@
+require 'delegate'
+#:stopdoc:
+
+# Stream wrapper that reads IOs in succession. Can be fed to Net::HTTP as post body stream. We use it internally to stream file content
+# instead of reading whole video files into memory. Strings passed to the constructor will be wrapped in StringIOs. By default it will auto-close
+# file handles when they have been read completely to prevent our uploader from leaking file handles
+#
+# chain = ChainIO.new(File.open(__FILE__), File.open('/etc/passwd'), "abcd")
+class YouTubeG::ChainIO
+  attr_accessor :autoclose
+
+  def initialize(*any_ios)
+    @autoclose = true
+    @chain = any_ios.flatten.map{|e| e.respond_to?(:read)  ? e : StringIO.new(e.to_s) }
+  end
+
+  def read(buffer_size = 1024)
+    # Read off the first element in the stack
+    current_io = @chain.shift
+    return false if !current_io
+    
+    buf = current_io.read(buffer_size)
+    if !buf && @chain.empty? # End of streams
+      release_handle(current_io) if @autoclose
+      false
+    elsif !buf # This IO is depleted, but next one is available
+      release_handle(current_io) if @autoclose
+      read(buffer_size)
+    elsif buf.length < buffer_size # This IO is depleted, but we were asked for more
+      release_handle(current_io) if @autoclose
+      buf + (read(buffer_size - buf.length) || '') # and recurse
+    else # just return the buffer
+      @chain.unshift(current_io) # put the current back
+      buf
+    end
+  end
+  
+  # Predict the length of all embedded IOs. Will automatically send file size.  
+  def expected_length
+    @chain.inject(0) do | len, io |
+      if io.respond_to?(:length)
+        len + (io.length - io.pos)
+      elsif io.is_a?(File)
+        len + File.size(io.path) - io.pos
+      else
+        raise "Cannot predict length of #{io.inspect}"
+      end
+    end
+  end
+    
+  private
+    def release_handle(io)
+      io.close if io.respond_to?(:close)
+    end
+end
+  
+# Net::HTTP only can send chunks of 1024 bytes. This is very inefficient, so we have a spare IO that will send more when asked for 1024.
+# We use delegation because the read call is recursive.
+class YouTubeG::GreedyChainIO < DelegateClass(YouTubeG::ChainIO)
+  BIG_CHUNK = 512 * 1024 # 500 kb
+  
+  def initialize(*with_ios)
+    __setobj__(YouTubeG::ChainIO.new(with_ios))
+  end
+  
+  def read(any_buffer_size)
+    __getobj__.read(BIG_CHUNK)
+  end
+end
+
+#:startdoc:

data/lib/youtube_g/client.rb

@@ -1,9 +1,9 @@
 class YouTubeG
   class Client
-    attr_accessor :logger
+    include YouTubeG::Logging
     
-    def initialize(logger=false)
-      @logger = Logger.new(STDOUT) if logger
+    # Previously this was a logger instance but we now do it globally
+    def initialize(legacy_debug_flag = nil)
     end
     
     # Retrieves an array of standard feed, custom query, or user videos.
@@ -53,7 +53,7 @@ class YouTubeG
         request = YouTubeG::Request::StandardSearch.new(params, request_params)
       end
       
-      logger.debug "Submitting request [url=#{request.url}]." if logger
+      logger.debug "Submitting request [url=#{request.url}]."
       parser = YouTubeG::Parser::VideosFeedParser.new(request.url)
       parser.parse
     end

data/lib/youtube_g/parser.rb

@@ -140,7 +140,7 @@ class YouTubeG
     class VideosFeedParser < VideoFeedParser #:nodoc:
 
     private
-      def parse_content(content) #:nodoc:
+      def parse_content(content)
         doc = REXML::Document.new(content)
         feed = doc.elements["feed"]
 

data/lib/youtube_g/request/base_search.rb

@@ -2,40 +2,23 @@ class YouTubeG
   module Request #:nodoc: 
     class BaseSearch #:nodoc:
       attr_reader :url
-
+      
       private
-
-      def base_url #:nodoc:
+      
+      def base_url
         "http://gdata.youtube.com/feeds/api/"                
       end
-
-      def set_instance_variables( variables ) #:nodoc:
+      
+      def set_instance_variables( variables )
         variables.each do |key, value| 
           name = key.to_s
           instance_variable_set("@#{name}", value) if respond_to?(name)
         end
       end
-
-      def build_query_params(params) #:nodoc:
-        # nothing to do if there are no params
-        return '' if (!params || params.empty?)
-
-        # build up the query param string, tacking on every key/value
-        # pair for which the value is non-nil
-        u = '?'
-        item_count = 0
-        params.keys.sort.each do |key|
-          value = params[key]
-          next if value.nil?
-
-          u << '&' if (item_count > 0)
-          u << "#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s)}"
-          item_count += 1
-        end
-
-        # if we found no non-nil values, we've got no params so just
-        # return an empty string
-        (item_count == 0) ? '' : u
+      
+      def build_query_params(params)
+        qs = params.to_a.map { | k, v | v.nil? ? nil : "#{YouTubeG.esc(k)}=#{YouTubeG.esc(v)}" }.compact.sort.join('&')
+        qs.empty? ? '' : "?#{qs}"
       end
     end
     

data/lib/youtube_g/request/standard_search.rb

@@ -22,11 +22,11 @@ class YouTubeG
 
       private
 
-      def base_url #:nodoc:
+      def base_url
         super << "standardfeeds/"        
       end
 
-      def to_youtube_params #:nodoc:
+      def to_youtube_params
         { 
           'max-results' => @max_results, 
           'orderby' => @order_by, 

data/lib/youtube_g/request/user_search.rb

@@ -26,11 +26,11 @@ class YouTubeG
 
       private
 
-      def base_url #:nodoc:
+      def base_url
         super << "users/"
       end
 
-      def to_youtube_params #:nodoc:
+      def to_youtube_params
         {
           'max-results' => @max_results,
           'orderby' => @order_by,

data/lib/youtube_g/request/video_search.rb

@@ -42,11 +42,11 @@ class YouTubeG
       
       private
       
-      def base_url #:nodoc:
+      def base_url
         super << "videos"
       end
       
-      def to_youtube_params #:nodoc:
+      def to_youtube_params
         {
           'max-results' => @max_results,
           'orderby' => @order_by,
@@ -62,7 +62,7 @@ class YouTubeG
       # Convert category symbols into strings and build the URL. GData requires categories to be capitalized. 
       # Categories defined like: categories => { :include => [:news], :exclude => [:sports], :either => [..] }
       # or like: categories => [:news, :sports]
-      def categories_to_params(categories) #:nodoc:
+      def categories_to_params(categories)
         if categories.respond_to?(:keys) and categories.respond_to?(:[])
           s = ""
           s << categories[:either].map { |c| c.to_s.capitalize }.join("%7C") << '/' if categories[:either]
@@ -76,15 +76,15 @@ class YouTubeG
 
       # Tags defined like: tags => { :include => [:football], :exclude => [:soccer], :either => [:polo, :tennis] }
       # or tags => [:football, :soccer]
-      def tags_to_params(tags) #:nodoc:
+      def tags_to_params(tags)
         if tags.respond_to?(:keys) and tags.respond_to?(:[])
           s = ""
-          s << tags[:either].map { |t| CGI.escape(t.to_s) }.join("%7C") << '/' if tags[:either]
-          s << tags[:include].map { |t| CGI.escape(t.to_s) }.join("/") << '/' if tags[:include]            
-          s << ("-" << tags[:exclude].map { |t| CGI.escape(t.to_s) }.join("/-")) << '/' if tags[:exclude]
+          s << tags[:either].map { |t| YouTubeG.esc(t.to_s) }.join("%7C") << '/' if tags[:either]
+          s << tags[:include].map { |t| YouTubeG.esc(t.to_s) }.join("/") << '/' if tags[:include]            
+          s << ("-" << tags[:exclude].map { |t| YouTubeG.esc(t.to_s) }.join("/-")) << '/' if tags[:exclude]
           s
         else
-          tags.map { |t| CGI.escape(t.to_s) }.join("/") << '/'
+          tags.map { |t| YouTubeG.esc(t.to_s) }.join("/") << '/'
         end          
       end
         

data/lib/youtube_g/request/video_upload.rb

@@ -1,23 +1,25 @@
 class YouTubeG
 
   module Upload
-    class UploadError < Exception; end
-    class AuthenticationError < Exception; end
-
-    # require 'youtube_g'
+    class UploadError < YouTubeG::Error; end
+    class AuthenticationError < YouTubeG::Error; end
+    
+    # Implements video uploads/updates/deletions
     #
-    # uploader = YouTubeG::Upload::VideoUpload.new("user", "pass", "dev-key")
-    # uploader.upload File.open("test.m4v"), :title => 'test',
+    #   require 'youtube_g'
+    #   
+    #   uploader = YouTubeG::Upload::VideoUpload.new("user", "pass", "dev-key")
+    #   uploader.upload File.open("test.m4v"), :title => 'test',
     #                                        :description => 'cool vid d00d',
     #                                        :category => 'People',
     #                                        :keywords => %w[cool blah test]
-
+    #
     class VideoUpload
-
+      
       def initialize user, pass, dev_key, client_id = 'youtube_g'
         @user, @pass, @dev_key, @client_id = user, pass, dev_key, client_id
       end
-
+      
       #
       # Upload "data" to youtube, where data is either an IO object or
       # raw file data.
@@ -32,97 +34,192 @@ class YouTubeG
       # Specifying :private will make the video private, otherwise it will be public.
       #
       # When one of the fields is invalid according to YouTube,
-      # an UploadError will be returned. Its message contains a list of newline separated
+      # an UploadError will be raised. Its message contains a list of newline separated
       # errors, containing the key and its error code.
       # 
       # When the authentication credentials are incorrect, an AuthenticationError will be raised.
       def upload data, opts = {}
-        data = data.respond_to?(:read) ? data.read : data
         @opts = { :mime_type => 'video/mp4',
-                  :filename => Digest::MD5.hexdigest(data),
                   :title => '',
                   :description => '',
                   :category => '',
                   :keywords => [] }.merge(opts)
-
-        uploadBody = generate_upload_body(boundary, video_xml, data)
-
-        uploadHeader = {
+        
+        @opts[:filename] ||= generate_uniq_filename_from(data)
+        
+        post_body_io = generate_upload_io(video_xml, data)
+        
+        upload_headers = authorization_headers.merge({
+            "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
+        
+        Net::HTTP.start(uploads_url) 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)
+        end
+      end
+      
+      # Updates a video in YouTube.  Requires:
+      #   :title
+      #   :description
+      #   :category
+      #   :keywords
+      # The following are optional attributes:
+      #   :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 = authorization_headers.merge({
+          "Content-Type"   => "application/atom+xml",
+          "Content-Length" => "#{update_body.length}",
+        })
+        
+        update_url = "/feeds/api/users/#{@user}/uploads/#{video_id}"
+        
+        Net::HTTP.start(base_url) do | session |
+          response = session.put(update_url, update_body, update_header)
+          raise_on_faulty_response(response)
+          
+          return YouTubeG::Parser::VideoFeedParser.new(response.body).parse
+        end
+      end
+      
+      # Delete a video on YouTube
+      def delete(video_id)
+        delete_header = authorization_headers.merge({
+          "Content-Type"   => "application/atom+xml",
+          "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)
+          raise_on_faulty_response(response)
+          return true
+        end
+      end
+      
+      private
+      
+      def uploads_url
+        ["uploads", base_url].join('.')
+      end
+      
+      def base_url
+        "gdata.youtube.com"
+      end
+      
+      def boundary 
+        "An43094fu"
+      end
+      
+      def authorization_headers
+        {
           "Authorization"  => "GoogleLogin auth=#{auth_token}",
           "X-GData-Client" => "#{@client_id}",
-          "X-GData-Key"    => "key=#{@dev_key}",
-          "Slug"           => "#{@opts[:filename]}",
-          "Content-Type"   => "multipart/related; boundary=#{boundary}",
-          "Content-Length" => "#{uploadBody.length}"
+          "X-GData-Key"    => "key=#{@dev_key}"
         }
-
-        Net::HTTP.start(base_url) do |upload|
-          response = upload.post('/feeds/api/users/' << @user << '/uploads', uploadBody, uploadHeader)
-          if response.code.to_i == 403
-            raise AuthenticationError, response.body[/<TITLE>(.+)<\/TITLE>/, 1]
-          elsif response.code.to_i != 201
-            upload_error = ''
-            xml = REXML::Document.new(response.body)
-            errors = xml.elements["//errors"]
-            errors.each do |error|
-              location = error.elements["location"].text[/media:group\/media:(.*)\/text\(\)/,1]
-              code = error.elements["code"].text
-              upload_error << sprintf("%s: %s\r\n", location, code)
-            end
-            raise UploadError, upload_error
-          end
-          xml = REXML::Document.new(response.body)
-          return xml.elements["//id"].text[/videos\/(.+)/, 1]
+      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)
         end
-
       end
-
-      private
-
-      def base_url #:nodoc:
-        "uploads.gdata.youtube.com"
+      
+      def raise_on_faulty_response(response)
+        if response.code.to_i == 403
+          raise AuthenticationError, response.body[/<TITLE>(.+)<\/TITLE>/, 1]
+        elsif response.code.to_i != 200
+          raise UploadError, parse_upload_error_from(response.body)
+        end 
       end
-
-      def boundary #:nodoc:
-        "An43094fu"
+      
+      def uploaded_video_id_from(string)
+        xml = REXML::Document.new(string)
+        xml.elements["//id"].text[/videos\/(.+)/, 1]
       end
-
-      def auth_token #:nodoc:
-        unless @auth_token
+      
+      # 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)
+        if data.respond_to?(:path)
+          Digest::MD5.hexdigest(data.path)
+        elsif data.respond_to?(:read)
+          chunk = data.read(1024)
+          data.rewind
+          Digest::MD5.hexdigest(chunk)
+        else
+          Digest::MD5.hexdigest(data)
+        end
+      end
+      
+      def auth_token
+        @auth_token ||= begin
           http = Net::HTTP.new("www.google.com", 443)
           http.use_ssl = true
-          body = "Email=#{CGI::escape @user}&Passwd=#{CGI::escape @pass}&service=youtube&source=#{CGI::escape @client_id}"
+          body = "Email=#{YouTubeG.esc @user}&Passwd=#{YouTubeG.esc @pass}&service=youtube&source=#{YouTubeG.esc @client_id}"
           response = http.post("/youtube/accounts/ClientLogin", body, "Content-Type" => "application/x-www-form-urlencoded")
           raise UploadError, response.body[/Error=(.+)/,1] if response.code.to_i != 200
           @auth_token = response.body[/Auth=(.+)/, 1]
-
         end
-        @auth_token
       end
-
-      def video_xml #:nodoc:
-        video_xml = ''
-        video_xml << '<?xml version="1.0"?>'
-        video_xml << '<entry xmlns="http://www.w3.org/2005/Atom" xmlns:media="http://search.yahoo.com/mrss/" xmlns:yt="http://gdata.youtube.com/schemas/2007">'
-        video_xml << '<media:group>'
-        video_xml << '<media:title type="plain">%s</media:title>'               % @opts[:title]
-        video_xml << '<media:description type="plain">%s</media:description>'   % @opts[:description]
-        video_xml << '<media:keywords>%s</media:keywords>'                      % @opts[:keywords].join(",")
-        video_xml << '<media:category scheme="http://gdata.youtube.com/schemas/2007/categories.cat">%s</media:category>' % @opts[:category]
-        video_xml << '<yt:private/>' if @opts[:private]
-        video_xml << '</media:group>'
-        video_xml << '</entry>'
+      
+      # TODO: isn't there a cleaner way to output top-notch XML without requiring stuff all over the place?
+      def video_xml
+        b = Builder::XML.new
+        b.instruct!
+        b.entry(:xmlns => "http://www.w3.org/2005/Atom", 'xmlns:media' => "http://search.yahoo.com/mrss/", 'xmlns:yt' => "http://gdata.youtube.com/schemas/2007") do | m |
+          m.tag!("media:group") do | mg |
+            mg.tag!("media:title", :type => "plain") { @opts[:title] }
+            mg.tag!("media:description", :type => "plain") { @opts[:description] }
+            mg.tag!("media:keywords") { @opts[:keywords].join(",") }
+            mg.tag!('media:category', :scheme => "http://gdata.youtube.com/schemas/2007/categories.cat") { @opts[:category] }
+            mg.tag!('yt:private') if @opts[:private]
+          end
+        end.to_s
       end
-
-      def generate_upload_body(boundary, video_xml, data) #:nodoc:
-        uploadBody = ""
-        uploadBody << "--#{boundary}\r\n"
-        uploadBody << "Content-Type: application/atom+xml; charset=UTF-8\r\n\r\n"
-        uploadBody << video_xml
-        uploadBody << "\r\n--#{boundary}\r\n"
-        uploadBody << "Content-Type: #{@opts[:mime_type]}\r\nContent-Transfer-Encoding: binary\r\n\r\n"
-        uploadBody << data
-        uploadBody << "\r\n--#{boundary}--\r\n"
+      
+      def generate_update_body(video_xml)
+        post_body = [
+          "--#{boundary}\r\n",
+          "Content-Type: application/atom+xml; charset=UTF-8\r\n\r\n",
+          video_xml,
+          "\r\n--#{boundary}\r\n",
+        ].join
+      end
+      
+      def generate_upload_io(video_xml, data)
+        post_body = [
+          "--#{boundary}\r\n",
+          "Content-Type: application/atom+xml; charset=UTF-8\r\n\r\n",
+          video_xml,
+          "\r\n--#{boundary}\r\n",
+          "Content-Type: #{@opts[:mime_type]}\r\nContent-Transfer-Encoding: binary\r\n\r\n",
+          data,
+          "\r\n--#{boundary}--\r\n",
+        ]
+        
+        # Use Greedy IO to not be limited by 1K chunks
+        YouTubeG::GreedyChainIO.new(post_body)
       end
 
     end

data/lib/youtube_g/version.rb

@@ -0,0 +1,3 @@
+class YouTubeG
+  VERSION = '0.5.1'
+end

data/test/helper.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'test/unit'
+require 'pp'
+require File.dirname(__FILE__) + '/../lib/youtube_g'
+
+YouTubeG.logger.level = Logger::ERROR

data/test/test_chain_io.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestChainIO < Test::Unit::TestCase
+  def setup
+    @klass = YouTubeG::ChainIO # save typing
+  end
+  
+  def test_should_support_read_from_one_io
+    io = @klass.new "abcd"
+    assert io.respond_to?(:read)
+    assert_equal "ab", io.read(2)
+    assert_equal "cd", io.read(2)
+    assert_equal false, io.read(2)
+  end
+  
+  def test_should_skip_over_depleted_streams
+    io = @klass.new '', '', '', '', 'ab'
+    assert_equal 'ab', io.read(2)
+  end
+  
+  def test_should_read_across_nultiple_streams_with_large_offset
+    io = @klass.new 'abc', '', 'def', '', 'ghij'
+    assert_equal 'abcdefgh', io.read(8)
+  end
+
+  def test_should_return_false_for_empty_items
+    io = @klass.new '', '', '', '', ''
+    assert_equal false, io.read(8)
+  end
+  
+  def test_should_support_overzealous_read
+    io = @klass.new "ab"
+    assert_equal "ab", io.read(5000)
+  end
+  
+  def test_should_predict_expected_length
+    io = @klass.new "ab", "cde"
+    assert_equal 5, io.expected_length
+  end
+
+  def test_should_predict_expected_length_with_prepositioned_io
+    first_buf = StringIO.new("ab")
+    first_buf.read(1)
+    
+    io = @klass.new first_buf, "cde"
+    assert_equal 4, io.expected_length
+  end
+  
+  def test_should_predict_expected_length_with_file_handle
+    test_size = File.size(__FILE__)
+    first_buf = StringIO.new("ab")
+    first_buf.read(1)
+    
+    io = @klass.new File.open(__FILE__), first_buf
+    assert_equal test_size + 1, io.expected_length
+  end
+  
+  def test_greedy
+    io = YouTubeG::GreedyChainIO.new("a" * (1024 * 513))
+    chunk = io.read(123)
+    assert_equal 1024 * 512, chunk.length, "Should have read the first 512 KB chunk at once instead"
+  end
+end

data/test/test_client.rb

@@ -1,8 +1,4 @@
-require 'rubygems'
-require 'test/unit'
-require 'pp'
-
-require 'youtube_g'
+require File.dirname(__FILE__) + '/helper'
 
 class TestClient < Test::Unit::TestCase
   def setup
@@ -157,14 +153,13 @@ class TestClient < Test::Unit::TestCase
     assert_valid_video video
   end
 
-  def test_should_disable_debug_if_debug_is_set_to_false
+  def test_should_always_return_a_logger
     @client = YouTubeG::Client.new
-    assert_nil @client.logger
+    assert_not_nil @client.logger
   end
   
-  def test_should_enable_logger_if_debug_is_true
-    @client = YouTubeG::Client.new(true)
-    assert_not_nil @client.logger
+  def test_should_not_bail_if_debug_is_true
+    assert_nothing_raised { YouTubeG::Client.new(true) }
   end
   
   def test_should_determine_if_nonembeddable_video_is_embeddable

data/test/test_video.rb

@@ -1,8 +1,4 @@
-require 'rubygems'
-require 'test/unit'
-require 'pp'
-
-require 'youtube_g'
+require File.dirname(__FILE__) + '/helper'
 
 class TestVideo < Test::Unit::TestCase
   def test_should_extract_unique_id_from_video_id

data/test/test_video_search.rb

@@ -1,8 +1,4 @@
-require 'rubygems'
-require 'test/unit'
-require 'pp'
-
-require 'youtube_g'
+require File.dirname(__FILE__) + '/helper'
 
 class TestVideoSearch < Test::Unit::TestCase
 

metadata

@@ -1,34 +1,61 @@
 --- !ruby/object:Gem::Specification 
 name: tmm1-youtube-g
 version: !ruby/object:Gem::Version 
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors: 
 - Shane Vitarana
 - Walter Korman
 - Aman Gupta
 - Filip H.F. Slagter
+- msp
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-01-07 00:00:00 -08:00
+date: 2009-03-02 00:00:00 -08:00
 default_executable: 
-dependencies: []
-
-description: An object-oriented Ruby wrapper for the YouTube GData API
-email: ruby-youtube-library@googlegroups.com
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: builder
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.3
+    version: 
+description: "youtube-g is a pure 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 queries to obtain well-targeted video search results.  More detail on the underlying source Google-provided API is available at:  http://code.google.com/apis/youtube/overview.html"
+email: shanev@gmail.com
 executables: []
 
 extensions: []
 
 extra_rdoc_files: 
 - History.txt
+- Manifest.txt
 - README.txt
+- TODO.txt
 files: 
 - History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- TODO.txt
+- lib/youtube_g.rb
+- lib/youtube_g/chain_io.rb
 - lib/youtube_g/client.rb
-- lib/youtube_g/logger.rb
 - lib/youtube_g/model/author.rb
 - lib/youtube_g/model/category.rb
 - lib/youtube_g/model/contact.rb
@@ -46,16 +73,14 @@ files:
 - lib/youtube_g/request/video_search.rb
 - lib/youtube_g/request/video_upload.rb
 - lib/youtube_g/response/video_search.rb
-- lib/youtube_g.rb
-- Manifest.txt
-- README.txt
+- lib/youtube_g/version.rb
+- test/helper.rb
+- test/test_chain_io.rb
 - test/test_client.rb
 - test/test_video.rb
 - test/test_video_search.rb
-- TODO.txt
-- youtube-g.gemspec
 has_rdoc: true
-homepage: http://youtube-g.rubyforge.org/
+homepage: http://rubyforge.org/projects/youtube-g/
 post_install_message: 
 rdoc_options: 
 - --main
@@ -76,12 +101,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: 
+rubyforge_project: youtube-g
 rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
-summary: An object-oriented Ruby wrapper for the YouTube GData API
+summary: Ruby client for the YouTube GData API
 test_files: 
+- test/test_chain_io.rb
 - test/test_client.rb
 - test/test_video.rb
 - test/test_video_search.rb

data/lib/youtube_g/logger.rb

@@ -1,25 +0,0 @@
-class YouTubeG
-  
-  # TODO: Why is this needed? Does this happen if running standalone w/o Rails?
-  # Anyway, isn't it easier to debug w/o the really long timestamp & log level?
-  # How often do you look at the timestamp and log level? Wouldn't it be nice to
-  # see your logger output first?
-  
-  # Extension of the base ruby Logger class to restore the default log
-  # level and timestamp formatting which is so rudely taken forcibly
-  # away from us by the Rails app's use of the ActiveSupport library
-  # that wholesale-ly modifies the Logger's format_message method.
-  #
-  class Logger < ::Logger
-    private
-      begin
-        # restore original log formatting to un-screw the screwage that is
-        # foisted upon us by the activesupport library's clean_logger.rb
-        alias format_message old_format_message
-
-      rescue NameError
-        # nothing for now -- this means we didn't need to alias since the
-        # method wasn't overridden
-      end
-  end
-end

data/youtube-g.gemspec

@@ -1,52 +0,0 @@
-spec = Gem::Specification.new do |s|
-  s.name = 'youtube-g'
-  s.version = '0.5.0'
-  s.date = '2009-01-07'
-  s.summary = 'An object-oriented Ruby wrapper for the YouTube GData API'
-  s.email = "ruby-youtube-library@googlegroups.com"
-  s.homepage = "http://youtube-g.rubyforge.org/"
-  s.description = "An object-oriented Ruby wrapper for the YouTube GData API"
-  s.has_rdoc = true
-  s.authors = ["Shane Vitarana", "Walter Korman", "Aman Gupta", "Filip H.F. Slagter"]
-
-  # ruby -rpp -e "pp Dir['**/*.*'].map"
-  s.files = [
-    "History.txt",
-     "lib/youtube_g/client.rb",
-     "lib/youtube_g/logger.rb",
-     "lib/youtube_g/model/author.rb",
-     "lib/youtube_g/model/category.rb",
-     "lib/youtube_g/model/contact.rb",
-     "lib/youtube_g/model/content.rb",
-     "lib/youtube_g/model/playlist.rb",
-     "lib/youtube_g/model/rating.rb",
-     "lib/youtube_g/model/thumbnail.rb",
-     "lib/youtube_g/model/user.rb",
-     "lib/youtube_g/model/video.rb",
-     "lib/youtube_g/parser.rb",
-     "lib/youtube_g/record.rb",
-     "lib/youtube_g/request/base_search.rb",
-     "lib/youtube_g/request/standard_search.rb",
-     "lib/youtube_g/request/user_search.rb",
-     "lib/youtube_g/request/video_search.rb",
-     "lib/youtube_g/request/video_upload.rb",
-     "lib/youtube_g/response/video_search.rb",
-     "lib/youtube_g.rb",
-     "Manifest.txt",
-     "README.txt",
-     "test/test_client.rb",
-     "test/test_video.rb",
-     "test/test_video_search.rb",
-     "TODO.txt",
-     "youtube-g.gemspec"
-  ]
-
-  s.test_files = [
-    "test/test_client.rb",
-    "test/test_video.rb",
-    "test/test_video_search.rb"
-  ]
-
-  s.rdoc_options = ["--main", "README.txt"]
-  s.extra_rdoc_files = ["History.txt", "README.txt"]
-end