tmm1-youtube-g 0.4.5 → 0.4.9

data/History.txt

@@ -1,5 +1,14 @@
 == trunk
-
+* 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]

data/Manifest.txt

@@ -17,6 +17,9 @@ 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

data/README.txt

@@ -32,6 +32,7 @@ Create a client:
 Basic queries:
 
   client.videos_by(:query => "penguin")
+  client.videos_by(:query => "penguin", :page => 2, :per_page => 15)
   client.videos_by(:tags => ['tiger', 'leopard'])
   client.videos_by(:categories => [:news, :sports])
   client.videos_by(:categories => [:news, :sports], :tags => ['soccer', 'football'])
@@ -40,6 +41,7 @@ Basic queries:
 Standard feeds:
 	
   client.videos_by(:most_viewed)
+  client.videos_by(:most_linked, :page => 3)
   client.videos_by(:top_rated, :time => :today)
 	
 Advanced queries (with boolean operators OR (either), AND (include), NOT (exclude)):

data/Rakefile

@@ -17,4 +17,9 @@ 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/TODO.txt

@@ -1,12 +1,10 @@
 [ ] stub out http request/response cycle for tests
-[ ] consider defaulting the client to no-logger, rather than outputting to STDOUT.
 [ ] allow specifying values as single items where you don't need to wrap in a list, e.g. :tags => :chickens instead of :tags => [ 'chickens' ]
 [ ] make sure symbols will work as well as tags everywhere (again, :tags => :chickens is same as :tags => 'chickens')
 [ ] figure out better structure for class/file (either rename request/video_search.rb or split into one class per file again)
 [ ] restore spaces after method def names
 [ ] use a proxy for testing with static sample result xml so we have repeatable tests
 [ ] Clean up tests using Shoulda to define contexts
-[ ] Consolidate requires
 [ ] Allow :category and :categories for query DSL
 [ ] Exception handling
 

data/lib/youtube_g.rb

@@ -1,3 +1,10 @@
+require 'logger'
+require 'open-uri'
+require 'net/https'
+require 'digest/md5'
+require 'rexml/document'
+require 'cgi'
+
 require File.dirname(__FILE__) + '/youtube_g/client'
 require File.dirname(__FILE__) + '/youtube_g/record'
 require File.dirname(__FILE__) + '/youtube_g/parser'
@@ -10,10 +17,13 @@ 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
+class YouTubeG #:nodoc:
   VERSION = '0.4.5'
 end

data/lib/youtube_g/client.rb

@@ -1,36 +1,81 @@
-require 'logger'
-
 class YouTubeG
   class Client
     attr_accessor :logger
     
-    def initialize(logger=Logger.new(STDOUT))
-      @logger = logger
+    def initialize(logger=false)
+      @logger = Logger.new(STDOUT) if logger
     end
-
-    # Params can be one of :most_viewed, :top_rated, :recently_featured, :watch_on_mobile
-    # Or :tags, :categories, :query, :user
+    
+    # Retrieves an array of standard feed, custom query, or user videos.
+    # 
+    # === Parameters
+    # If fetching videos for a standard feed:
+    #   params<Symbol>:: Accepts a symbol of :top_rated, :top_favorites, :most_viewed, 
+    #                    :most_popular, :most_recent, :most_discussed, :most_linked, 
+    #                    :most_responded, :recently_featured, and :watch_on_mobile.
+    #  
+    #   You can find out more specific information about what each standard feed provides
+    #   by visiting: http://code.google.com/apis/youtube/reference.html#Standard_feeds                 
+    #   
+    #   options<Hash> (optional)::  Accepts the options of :time, :page (default is 1), 
+    #                               and :per_page (default is 25). :offset and :max_results
+    #                               can also be passed for a custom offset.
+    #  
+    # If fetching videos by tags, categories, query:
+    #   params<Hash>:: Accepts the keys :tags, :categories, :query, :order_by, 
+    #                  :author, :racy, :response_format, :video_format, :page (default is 1), 
+    #                  and :per_page(default is 25)
+    #                  
+    #   options<Hash>:: Not used. (Optional)
+    # 
+    # If fetching videos for a particular user:
+    #   params<Hash>:: Key of :user with a value of the username.
+    #   options<Hash>:: Not used. (Optional)
+    # === Returns
+    # YouTubeG::Response::VideoSearch
     def videos_by(params, options={})
+      request_params = params.respond_to?(:to_hash) ? params : options
+      request_params[:page] ||= 1
+      
+      unless request_params[:max_results]
+        request_params[:max_results] = request_params[:per_page] || 25
+      end
+      
+      unless request_params[:offset]
+        request_params[:offset] = calculate_offset(request_params[:page], request_params[:max_results] )
+      end
+      
       if params.respond_to?(:to_hash) and not params[:user]
-        request = YouTubeG::Request::VideoSearch.new(params)
-
+        request = YouTubeG::Request::VideoSearch.new(request_params)
       elsif (params.respond_to?(:to_hash) && params[:user]) || (params == :favorites)
-        request = YouTubeG::Request::UserSearch.new(params, options)
-
+        request = YouTubeG::Request::UserSearch.new(request_params, options)
       else
-        request = YouTubeG::Request::StandardSearch.new(params, options)
+        request = YouTubeG::Request::StandardSearch.new(params, request_params)
       end
       
-      logger.debug "Submitting request [url=#{request.url}]."
+      logger.debug "Submitting request [url=#{request.url}]." if logger
       parser = YouTubeG::Parser::VideosFeedParser.new(request.url)
       parser.parse
     end
     
+    # Retrieves a single YouTube video.
+    #
+    # === Parameters
+    #   vid<String>:: The ID or URL of the video that you'd like to retrieve.
+    # 
+    # === Returns
+    # YouTubeG::Model::Video
     def video_by(vid)
       video_id = vid =~ /^http/ ? vid : "http://gdata.youtube.com/feeds/videos/#{vid}"
       parser = YouTubeG::Parser::VideoFeedParser.new(video_id)
       parser.parse
     end
     
+    private
+    
+    def calculate_offset(page, per_page)
+      page == 1 ? 1 : ((per_page * page) - per_page + 1)
+    end
+    
   end
 end

data/lib/youtube_g/logger.rb

@@ -1,5 +1,3 @@
-require 'logger'
-
 class YouTubeG
   
   # TODO: Why is this needed? Does this happen if running standalone w/o Rails?

data/lib/youtube_g/model/author.rb

@@ -1,7 +1,10 @@
 class YouTubeG
   module Model
     class Author < YouTubeG::Record
+      # *String*: Author's YouTube username.
       attr_reader :name
+      
+      # *String*: Feed URL of the author.
       attr_reader :uri
     end
   end

data/lib/youtube_g/model/category.rb

@@ -1,7 +1,10 @@
 class YouTubeG
   module Model
     class Category < YouTubeG::Record
-      attr_reader :label
+      # *String*:: Name of the YouTube category
+      attr_reader :label 
+      
+      # *String*:: Identifies the type of item described.
       attr_reader :term
     end
   end

data/lib/youtube_g/model/contact.rb

@@ -1,7 +1,15 @@
 class YouTubeG
   module Model
     class Contact < YouTubeG::Record
+      # *String*:: Identifies the status of a contact.
+      #
+      # * The tag's value will be accepted if the authenticated user and the contact have marked each other as friends.
+      # * The tag's value will be requested if the contact has asked to be added to the authenticated user's contact list, but the request has not yet been accepted (or rejected).
+      # * The tag's value will be pending if the authenticated user has asked to be added to the contact's contact list, but the request has not yet been accepted or rejected.
+      #
       attr_reader :status
+      
+      # *String*:: The Youtube username of the contact.
       attr_reader :username
     end
   end

data/lib/youtube_g/model/content.rb

@@ -1,10 +1,15 @@
 class YouTubeG
   module Model
     class Content < YouTubeG::Record
+      # *Boolean*:: Description of the video.
       attr_reader :default
+      # *Fixnum*:: Length of the video in seconds.
       attr_reader :duration
+      # YouTubeG::Model::Video::Format:: Specifies the video format of the video object
       attr_reader :format
+      # *String*:: Specifies the MIME type of the media object.
       attr_reader :mime_type
+      # *String*:: Specifies the URL for the media object.
       attr_reader :url
       
       alias :is_default? :default

data/lib/youtube_g/model/playlist.rb

@@ -1,6 +1,7 @@
 class YouTubeG
   module Model
     class Playlist < YouTubeG::Record
+      # *String*:: User entered description for the playlist.
       attr_reader :description
     end
   end

data/lib/youtube_g/model/rating.rb

@@ -1,9 +1,16 @@
 class YouTubeG
   module Model
     class Rating < YouTubeG::Record
+      # *Float*:: Average rating given to the video
       attr_reader :average
+      
+      # *Fixnum*:: Maximum rating that can be assigned to the video
       attr_reader :max
+      
+      # *Fixnum*:: Minimum rating that can be assigned to the video
       attr_reader :min
+      
+      # *Fixnum*:: Indicates how many people have rated the video
       attr_reader :rater_count
     end
   end

data/lib/youtube_g/model/thumbnail.rb

@@ -1,9 +1,16 @@
 class YouTubeG
   module Model
     class Thumbnail < YouTubeG::Record
+      # *String*:: URL for the thumbnail image.
       attr_reader :url
+      
+      # *Fixnum*:: Height of the thumbnail image.
       attr_reader :height
+      
+      # *Fixnum*:: Width of the thumbnail image.
       attr_reader :width
+      
+      # *String*:: Specifies the time offset at which the frame shown in the thumbnail image appears in the video.
       attr_reader :time
     end
   end

data/lib/youtube_g/model/video.rb

@@ -1,91 +1,165 @@
+# TODO
+#  * self atom feed
+#  * alternate youtube watch url
+#  * comments feedLink
+
 class YouTubeG
   module Model
     class Video < YouTubeG::Record
       # Describes the various file formats in which a Youtube video may be
       # made available and allows looking them up by format code number.
-      #
       class Format
         @@formats = Hash.new
 
+        # Instantiates a new video format object.
+        #
+        # == Parameters
+        #   :format_code<Fixnum>:: The Youtube Format code of the object. 
+        #   :name<Symbol>:: The name of the format
+        #   
+        # == Returns
+        #   YouTubeG::Model::Video::Format: Video format object
         def initialize(format_code, name)
           @format_code = format_code
           @name = name
 
           @@formats[format_code] = self          
         end
-
+        
+        # Allows you to get the video format for a specific format code.
+        # 
+        # A full list of format codes is available at:
+        # 
+        # http://code.google.com/apis/youtube/reference.html#youtube_data_api_tag_media:content
+        #
+        # == Parameters
+        #   :format_code<Fixnum>:: The Youtube Format code of the object. 
+        #   
+        # == Returns
+        #   YouTubeG::Model::Video::Format: Video format object
         def self.by_code(format_code)
           @@formats[format_code]
         end
 
-        # Flash format on YouTube site. All videos are available in this
-        # format.
-        #
+        # Flash format on YouTube site. All videos are available in this format.
         FLASH = YouTubeG::Model::Video::Format.new(0, :flash)
 
-        # RTSP streaming URL for mobile video playback. H.263 video (176x144)
-        # and AMR audio.
-        #
+        # RTSP streaming URL for mobile video playback. H.263 video (176x144) and AMR audio.
         RTSP = YouTubeG::Model::Video::Format.new(1, :rtsp)
 
         # HTTP URL to the embeddable player (SWF) for this video. This format
         # is not available for a video that is not embeddable.
-        #
         SWF = YouTubeG::Model::Video::Format.new(5, :swf)
         
+        # RTSP streaming URL for mobile video playback. MPEG-4 SP video (up to 176x144) and AAC audio.
         THREE_GPP = YouTubeG::Model::Video::Format.new(6, :three_gpp)
       end
-
+      
+      # *Fixnum*:: Duration of a video in seconds.
       attr_reader :duration
+      
+      # *Boolean*:: Specifies that a video may or may not be embedded on other websites.
       attr_reader :noembed
+      
+      # *Fixnum*:: Specifies the order in which the video appears in a playlist.
       attr_reader :position
+      
+      # *Boolean*:: Specifies that a video is flagged as adult or not.
       attr_reader :racy
-      attr_reader :statistics
       
+      # *String*: Specifies a URI that uniquely and permanently identifies the video.
       attr_reader :video_id
+      
+      # *Time*:: When the video was published on Youtube.
       attr_reader :published_at
+      
+      # *Time*:: When the video's data was last updated.
       attr_reader :updated_at
+      
+      # *Array*:: A array of YouTubeG::Model::Category objects that describe the videos categories. 
       attr_reader :categories
+      
+      # *Array*:: An array of words associated with the video.
       attr_reader :keywords
+      
+      # *String*:: Description of the video.
       attr_reader :description
+      
+      # *String*:: Title for the video.
       attr_reader :title
+      
+      # *String*:: Description of the video.
       attr_reader :html_content
+      
+      # YouTubeG::Model::Author:: Information about the YouTube user who owns a piece of video content.
       attr_reader :author
-
-      # YouTubeG::Model::Content records describing the individual media content
-      # data available for this video.  Most, but not all, videos offer this.
+      
+      # *Array*:: An array of YouTubeG::Model::Content objects describing the individual media content data available for this video.  Most, but not all, videos offer this.
       attr_reader :media_content
-
-      attr_reader :thumbnails         # YouTubeG::Model::Thumbnail records
+      
+      # *Array*:: An array of YouTubeG::Model::Thumbnail objects that contain information regarding the videos thumbnail images. 
+      attr_reader :thumbnails
+      
+      # *String*:: The link to watch the URL on YouTubes website.
       attr_reader :player_url
+      
+      # YouTubeG::Model::Rating:: Information about the videos rating.
       attr_reader :rating
+      
+      # *Fixnum*:: Number of times that the video has been viewed
       attr_reader :view_count
-
-      # TODO:
-      # self atom feed
-      # alternate youtube watch url
-      # responses feed
-      # comments feedLink
-
+      
+      attr_reader :statistics
+      
+      # Videos related to the current video.
+      #
+      # === Returns
+      #   YouTubeG::Response::VideoSearch
       def related
         YouTubeG::Parser::VideosFeedParser.new("http://gdata.youtube.com/feeds/api/videos/#{unique_id}/related").parse
       end
       
-      # For convenience, the video_id with the URL stripped out, useful for searching for the video again
-      # without having to store it anywhere. A regular query search, with this id will return the same video.
-      # http://gdata.youtube.com/feeds/videos/ZTUVgYoeN_o
+      # Video responses to the current video.
+      #
+      # === Returns
+      #   YouTubeG::Response::VideoSearch   
+      def responses
+        YouTubeG::Parser::VideosFeedParser.new("http://gdata.youtube.com/feeds/api/videos/#{unique_id}/responses").parse
+      end
+      
+      # The ID of the video, useful for searching for the video again without having to store it anywhere. 
+      # A regular query search, with this id will return the same video.
+      # 
+      # === Example
+      #   >> video.unique_id
+      #   => "ZTUVgYoeN_o"
+      #   
+      # === Returns
+      #   String: The Youtube video id.
       def unique_id
         video_id[/videos\/([^<]+)/, 1]
       end
       
-      def can_embed?
+      # Allows you to check whether the video can be embedded on a webpage.
+      #
+      # === Returns
+      #   Boolean: True if the video can be embedded, false if not.
+      def embeddable?
         not @noembed
       end
       
+      # Provides a URL and various other types of information about a video.
+      # 
+      # === Returns
+      #   YouTubeG::Model::Content: Data about the embeddable video.
       def default_media_content
         @media_content.find { |c| c.is_default? }
       end
       
+      # Gives you the HTML to embed the video on your website.
+      #
+      # === Returns
+      #   String: The HTML for embedding the video on your website.
       def embed_html(width = 425, height = 350)
         <<EDOC
 <object width="#{width}" height="#{height}">
@@ -97,6 +171,10 @@ class YouTubeG
 EDOC
       end
 
+      # The URL needed for embedding the video in a page.
+      #
+      # === Returns
+      #   String: Absolute URL for embedding video
       def embed_url
         @player_url.sub('watch?', '').sub('=', '/')          
       end

data/lib/youtube_g/parser.rb

@@ -1,10 +1,6 @@
-require 'cgi'
-require 'open-uri'
-require 'rexml/document'
-
 class YouTubeG
-  module Parser
-    class FeedParser
+  module Parser #:nodoc:
+    class FeedParser #:nodoc:
       def initialize(url)
         @url = url
       end
@@ -14,17 +10,16 @@ class YouTubeG
       end      
     end
 
-    class VideoFeedParser < FeedParser
+    class VideoFeedParser < FeedParser #:nodoc:
       
       def parse_content(content)
         doc = REXML::Document.new(content)
         entry = doc.elements["entry"]
-        
         parse_entry(entry)
       end
 
     protected
-      def parse_entry(entry)
+      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)
@@ -94,7 +89,7 @@ class YouTubeG
         view_count = (el = entry.elements["yt:statistics"]) ? el.attributes["viewCount"].to_i : 0
 
         noembed = entry.elements["yt:noembed"] ? true : false
-        racy = entry.elements["yt:racy"] ? true : false
+        racy = entry.elements["media:rating"] ? true : false
 
         YouTubeG::Model::Video.new(
           :video_id => video_id,
@@ -116,7 +111,7 @@ class YouTubeG
           :racy => racy)
       end
 
-      def parse_media_content (media_content_element)
+      def parse_media_content (media_content_element) 
         content_url = media_content_element.attributes["url"]
         format_code = media_content_element.attributes["yt:format"].to_i
         format = YouTubeG::Model::Video::Format.by_code(format_code)
@@ -133,10 +128,10 @@ class YouTubeG
       end      
     end
 
-    class VideosFeedParser < VideoFeedParser
+    class VideosFeedParser < VideoFeedParser #:nodoc:
 
     private
-      def parse_content(content)
+      def parse_content(content) #:nodoc:
         doc = REXML::Document.new(content)
         feed = doc.elements["feed"]
 

data/lib/youtube_g/record.rb

@@ -1,5 +1,5 @@
 class YouTubeG
-  class Record
+  class Record #:nodoc:
     def initialize (params)
       return if params.nil?
 

data/lib/youtube_g/request/video_search.rb

@@ -1,48 +1,6 @@
 class YouTubeG
-  
-  # The goal of the classes in this module is to build the request URLs for each type of search
-  module Request
-    
-    class BaseSearch
-      attr_reader :url
-
-      def base_url
-        "http://gdata.youtube.com/feeds/api/"                
-      end
-    end
-    
-    class UserSearch < BaseSearch
-      
-      def initialize(params, options={})
-        @url = base_url
-        return @url << "#{options[:user]}/favorites" if params == :favorites
-        @url << "#{params[:user]}/uploads" if params[:user]
-      end
-      
-      def base_url
-        super << "users/"
-      end
-    end
-        
-    class StandardSearch < BaseSearch
-      TYPES = [ :most_viewed, :top_rated, :recently_featured, :watch_on_mobile ]
-      TIMES = [ :all_time, :today, :this_week, :this_month ]
-      
-      def initialize(type, options={})
-        if TYPES.include?(type)
-          @url = base_url << type.to_s
-          @url << "?time=#{CGI.escape(options.delete(:time).to_s)}" if TIMES.include?(options[:time])
-        else
-          raise "Invalid type, must be one of: #{ TYPES.map { |t| t.to_s }.join(", ") }"
-        end
-      end
-      
-      def base_url
-        super << "standardfeeds/"        
-      end
-    end
-    
-    class VideoSearch < BaseSearch
+  module Request #:nodoc:    
+    class VideoSearch < BaseSearch #:nodoc:
       # From here: http://code.google.com/apis/youtube/reference.html#yt_format
       ONLY_EMBEDDABLE = 5
 
@@ -58,34 +16,22 @@ class YouTubeG
       attr_reader :author
       
       def initialize(params={})
-        # XXX I think we want to delete the line below
-        return if params.nil?
-
-        # initialize our various member data to avoid warnings and so we'll
+        # Initialize our various member data to avoid warnings and so we'll
         # automatically fall back to the youtube api defaults
-        @max_results = nil
-        @order_by = nil
-        @offset = nil
-        @query = nil
-        @response_format = nil
-        @video_format = nil
-        @racy = nil
-        @author = nil
-
-        # build up the url corresponding to this request
+        @max_results, @order_by, 
+        @offset, @query, 
+        @response_format, @video_format, 
+        @racy, @author = nil
         @url = base_url
         
-        # http://gdata.youtube.com/feeds/videos/T7YazwP8GtY
+        # Return a single video (base_url + /T7YazwP8GtY)
         return @url << "/" << params[:video_id] if params[:video_id]
         
         @url << "/-/" if (params[:categories] || params[:tags])
         @url << categories_to_params(params.delete(:categories)) if params[:categories]
         @url << tags_to_params(params.delete(:tags)) if params[:tags]
 
-        params.each do |key, value| 
-          name = key.to_s
-          instance_variable_set("@#{name}", value) if respond_to?(name)
-        end
+        set_instance_variables(params)
         
         if( params[ :only_embeddable ] )
           @video_format = ONLY_EMBEDDABLE
@@ -94,11 +40,13 @@ class YouTubeG
         @url << build_query_params(to_youtube_params)
       end
       
-      def base_url
+      private
+      
+      def base_url #:nodoc:
         super << "videos"
       end
       
-      def to_youtube_params
+      def to_youtube_params #:nodoc:
         {
           'max-results' => @max_results,
           'orderby' => @order_by,
@@ -110,58 +58,35 @@ class YouTubeG
           'author' => @author
         }
       end
-      
-      private
-        # 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)
-          if categories.respond_to?(:keys) and categories.respond_to?(:[])
-            s = ""
-            s << categories[:either].map { |c| c.to_s.capitalize }.join("%7C") << '/' if categories[:either]
-            s << categories[:include].map { |c| c.to_s.capitalize }.join("/") << '/' if categories[:include]            
-            s << ("-" << categories[:exclude].map { |c| c.to_s.capitalize }.join("/-")) << '/' if categories[:exclude]
-            s
-          else
-            categories.map { |c| c.to_s.capitalize }.join("/") << '/'
-          end
-        end
-        
-        # Tags defined like: tags => { :include => [:football], :exclude => [:soccer], :either => [:polo, :tennis] }
-        # or tags => [:football, :soccer]
-        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
-          else
-            tags.map { |t| CGI.escape(t.to_s) }.join("/") << '/'
-          end          
-        end
 
-        def build_query_params(params)
-          # 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.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
+      # 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:
+        if categories.respond_to?(:keys) and categories.respond_to?(:[])
+          s = ""
+          s << categories[:either].map { |c| c.to_s.capitalize }.join("%7C") << '/' if categories[:either]
+          s << categories[:include].map { |c| c.to_s.capitalize }.join("/") << '/' if categories[:include]            
+          s << ("-" << categories[:exclude].map { |c| c.to_s.capitalize }.join("/-")) << '/' if categories[:exclude]
+          s
+        else
+          categories.map { |c| c.to_s.capitalize }.join("/") << '/'
         end
+      end
+
+      # Tags defined like: tags => { :include => [:football], :exclude => [:soccer], :either => [:polo, :tennis] }
+      # or tags => [:football, :soccer]
+      def tags_to_params(tags) #:nodoc:
+        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
+        else
+          tags.map { |t| CGI.escape(t.to_s) }.join("/") << '/'
+        end          
+      end
         
     end
   end

data/lib/youtube_g/request/video_upload.rb

@@ -1,12 +1,8 @@
-require 'net/https'
-require 'digest/md5'
-require 'rexml/document'
-require 'cgi'
-
 class YouTubeG
 
   module Upload
     class UploadError < Exception; end
+    class AuthenticationError < Exception; end
 
     # require 'youtube_g'
     #
@@ -32,8 +28,14 @@ class YouTubeG
       #   :description
       #   :category
       #   :keywords
+      #   :private
+      # 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
+      # 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',
@@ -56,6 +58,19 @@ class YouTubeG
 
         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
@@ -64,15 +79,15 @@ class YouTubeG
 
       private
 
-      def base_url
+      def base_url #:nodoc:
         "uploads.gdata.youtube.com"
       end
 
-      def boundary
+      def boundary #:nodoc:
         "An43094fu"
       end
 
-      def auth_token
+      def auth_token #:nodoc:
         unless @auth_token
           http = Net::HTTP.new("www.google.com", 443)
           http.use_ssl = true
@@ -85,18 +100,21 @@ class YouTubeG
         @auth_token
       end
 
-      def video_xml
-        %[<?xml version="1.0"?>
-           <entry xmlns="http://www.w3.org/2005/Atom" xmlns:media="http://search.yahoo.com/mrss/" xmlns:yt="http://gdata.youtube.com/schemas/2007">
-           <media:group>
-           <media:title type="plain">#{@opts[:title]}</media:title>
-           <media:description type="plain">#{@opts[:description]}</media:description>
-           <media:category scheme="http://gdata.youtube.com/schemas/2007/categories.cat">#{@opts[:category]}</media:category>
-           <media:keywords>#{@opts[:keywords].join ","}</media:keywords>
-           </media:group></entry> ]
+      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>'
       end
 
-      def generate_upload_body(boundary, video_xml, data)
+      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"

data/lib/youtube_g/response/video_search.rb

@@ -1,22 +1,22 @@
 class YouTubeG
   module Response
     class VideoSearch < YouTubeG::Record
-      # the unique feed identifying url
-      attr_reader :feed_id
+      # *String*:: Unique feed identifying url.
+      attr_reader :feed_id 
       
-      # the number of results per page
+      # *Fixnum*:: Number of results per page.
       attr_reader :max_result_count
       
-      # the 1-based offset index into the full result set
+      # *Fixnum*:: 1-based offset index into the full result set.
       attr_reader :offset
       
-      # the total number of results available for the original request
+      # *Fixnum*:: Total number of results available for the original request.
       attr_reader :total_result_count
 
-      # the date and time at which the feed was last updated
+      # *Time*:: Date and time at which the feed was last updated
       attr_reader :updated_at
 
-      # the list of Video records
+      # *Array*:: Array of YouTubeG::Model::Video records
       attr_reader :videos
     end
   end

data/test/test_client.rb

@@ -12,7 +12,7 @@ class TestClient < Test::Unit::TestCase
   def test_should_respond_to_a_basic_query
     response = @client.videos_by(:query => "penguin")
   
-    assert_equal "http://gdata.youtube.com/feeds/api/videos?start-index=1&max-results=25&vq=penguin", response.feed_id
+    assert_equal "http://gdata.youtube.com/feeds/api/videos", response.feed_id
     assert_equal 25, response.max_result_count
     assert_equal 25, response.videos.length
     assert_equal 1, response.offset
@@ -22,10 +22,41 @@ class TestClient < Test::Unit::TestCase
     response.videos.each { |v| assert_valid_video v }
   end
   
+    def test_should_respond_to_a_basic_query_with_offset_and_max_results
+    response = @client.videos_by(:query => "penguin", :offset => 15, :max_results => 30)
+  
+    assert_equal "http://gdata.youtube.com/feeds/api/videos", response.feed_id
+    assert_equal 30, response.max_result_count
+    assert_equal 30, response.videos.length
+    assert_equal 15, response.offset
+    assert(response.total_result_count > 100)
+    assert_instance_of Time, response.updated_at
+  
+    response.videos.each { |v| assert_valid_video v }
+  end
+  
+  def test_should_respond_to_a_basic_query_with_paging
+    response = @client.videos_by(:query => "penguin") 
+    assert_equal "http://gdata.youtube.com/feeds/api/videos", response.feed_id
+    assert_equal 25, response.max_result_count
+    assert_equal 1, response.offset
+
+    response = @client.videos_by(:query => "penguin", :page => 2) 
+    assert_equal "http://gdata.youtube.com/feeds/api/videos", response.feed_id
+    assert_equal 25, response.max_result_count
+    assert_equal 26, response.offset
+    
+    response2 = @client.videos_by(:query => "penguin", :page => 3) 
+    assert_equal "http://gdata.youtube.com/feeds/api/videos", response2.feed_id
+    assert_equal 25, response2.max_result_count
+    assert_equal 51, response2.offset
+  end
+  
+  
   def test_should_get_videos_for_multiword_metasearch_query
     response = @client.videos_by(:query => 'christina ricci')
   
-    assert_equal "http://gdata.youtube.com/feeds/api/videos?start-index=1&max-results=25&vq=christina+ricci", response.feed_id
+    assert_equal "http://gdata.youtube.com/feeds/api/videos", response.feed_id
     assert_equal 25, response.max_result_count
     assert_equal 25, response.videos.length
     assert_equal 1, response.offset
@@ -109,19 +140,18 @@ class TestClient < Test::Unit::TestCase
   # end
   
   def test_should_get_videos_for_query_search_with_categories_excluded
-    response = @client.videos_by(:query => 'bench press', :categories => { :exclude => [:comedy, :entertainment] },
-                                 :max_results => 10)
-    assert_equal "<object width=\"425\" height=\"350\">\n  <param name=\"movie\" value=\"http://www.youtube.com/v/BlDWdfTAx8o\"></param>\n  <param name=\"wmode\" value=\"transparent\"></param>\n  <embed src=\"http://www.youtube.com/v/BlDWdfTAx8o\" type=\"application/x-shockwave-flash\" \n   wmode=\"transparent\" width=\"425\" height=\"350\"></embed>\n</object>\n", response.videos.first.embed_html
-    response.videos.each { |v| assert_valid_video v }
-  end
-  
-  def test_should_be_able_to_pass_in_logger
-    @client = YouTubeG::Client.new(Logger.new(STDOUT))
-    assert_not_nil @client.logger
+    video = @client.video_by("EkF4JD2rO3Q")
+    assert_equal "<object width=\"425\" height=\"350\">\n  <param name=\"movie\" value=\"http://www.youtube.com/v/EkF4JD2rO3Q\"></param>\n  <param name=\"wmode\" value=\"transparent\"></param>\n  <embed src=\"http://www.youtube.com/v/EkF4JD2rO3Q\" 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_create_logger_if_not_passed_in
+  def test_should_disable_debug_if_debug_is_set_to_false
     @client = YouTubeG::Client.new
+    assert_nil @client.logger
+  end
+  
+  def test_should_enable_logger_if_debug_is_true
+    @client = YouTubeG::Client.new(true)
     assert_not_nil @client.logger
   end
   
@@ -129,14 +159,14 @@ class TestClient < Test::Unit::TestCase
     response = @client.videos_by(:query => "avril lavigne girlfriend")
   
     video = response.videos.first
-    assert !video.can_embed?
+    assert !video.embeddable?
   end
 
   def test_should_determine_if_embeddable_video_is_embeddable
     response = @client.videos_by(:query => "strongbad")
   
     video = response.videos.first
-    assert video.can_embed?
+    assert video.embeddable?
   end
   
   def test_should_retrieve_video_by_id

data/test/test_video.rb

@@ -23,8 +23,20 @@ class TestVideo < Test::Unit::TestCase
     assert_equal 25, response.max_result_count
     assert_equal 25, response.videos.length
     assert_equal 1, response.offset
-    puts response.total_result_count
     assert(response.total_result_count > 0)
     assert_instance_of Time, response.updated_at
   end
+  
+  def test_should_have_response_videos
+    video = YouTubeG::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 1, response.offset
+    assert(response.total_result_count > 0)
+    assert_instance_of Time, response.updated_at
+  end
+  
 end

data/test/test_video_search.rb

@@ -61,17 +61,27 @@ class TestVideoSearch < Test::Unit::TestCase
     request = YouTubeG::Request::StandardSearch.new(:most_viewed)
     assert_equal "http://gdata.youtube.com/feeds/api/standardfeeds/most_viewed", request.url    
   end
+  
+  def test_should_build_url_for_top_rated_for_today
+    request = YouTubeG::Request::StandardSearch.new(:top_rated, :time => :today)
+    assert_equal "http://gdata.youtube.com/feeds/api/standardfeeds/top_rated?time=today", request.url    
+  end  
+  
+  def test_should_build_url_for_most_viewed_offset_and_max_results_without_time
+    request = YouTubeG::Request::StandardSearch.new(:top_rated, :offset => 5, :max_results => 10)
+    assert_equal "http://gdata.youtube.com/feeds/api/standardfeeds/top_rated?max-results=10&start-index=5", request.url   
+  end
+  
+  def test_should_build_url_for_most_viewed_offset_and_max_results_with_time
+    request = YouTubeG::Request::StandardSearch.new(:top_rated, :offset => 5, :max_results => 10, :time => :today)
+    assert_equal "http://gdata.youtube.com/feeds/api/standardfeeds/top_rated?time=today&max-results=10&start-index=5", request.url   
+  end
 
   def test_should_raise_exception_for_invalid_type
     assert_raise RuntimeError do
       request = YouTubeG::Request::StandardSearch.new(:most_viewed_yo)
     end
   end
-
-  def test_should_build_url_for_top_rated_for_today
-    request = YouTubeG::Request::StandardSearch.new(:top_rated, :time => :today)
-    assert_equal "http://gdata.youtube.com/feeds/api/standardfeeds/top_rated?time=today", request.url    
-  end  
   
   # -- Complex Video Queries -------------------------------------------------------------------------
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tmm1-youtube-g
 version: !ruby/object:Gem::Version 
-  version: 0.4.5
+  version: 0.4.9
 platform: ruby
 authors: 
 - Shane Vitarana