youtube-g 0.4.0

data/History.txt

@@ -0,0 +1,12 @@
+== 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!
+

data/Manifest.txt

@@ -0,0 +1,24 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+TODO.txt
+lib/youtube_g.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
+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/video_search.rb
+lib/youtube_g/response/video_search.rb
+test/test_client.rb
+test/test_video.rb
+test/test_video_search.rb

data/README.txt

@@ -0,0 +1,66 @@
+youtube-g
+    by Shane Vitarana and Walter Korman
+    http://rubyforge.org/projects/youtube-g/
+
+== DESCRIPTION:
+  
+youtube-g is a pure Ruby client for the YouTube GData API.
+
+== FEATURES/PROBLEMS:
+  
+* Aims to be in parity with Google's YouTube GData API (it is currently not complete)
+
+== SYNOPSIS:
+
+	Basic queries:
+	
+	@client = YouTubeG::Client.new
+	@client.videos_by(:query => "penguin")
+	@client.videos_by(:tags => ['tiger', 'leopard'])
+	@client.videos_by(:categories => [:news, :sports])
+	@client.videos_by(:categories => [:news, :sports], :tags => ['soccer', 'football'])
+	@client.videos_by(:user => 'liz')
+	
+	Standard feeds:
+	
+	@client.videos_by(:most_viewed)
+	@client.videos_by(:top_rated, :time => :today)
+	
+	Advanced queries (with boolean operators OR (either), AND (include), NOT (exclude)):
+	
+	@client.videos_by(:categories => { :either => [:news, :sports], :exclude => [:comedy] }, :tags => { :include => ['football'], :exclude => ['soccer'] })
+
+
+== REQUIREMENTS:
+
+* None
+
+== INSTALL:
+
+* sudo gem install youtube-g
+
+== LICENSE:
+
+MIT License
+
+Copyright (c) 2007 Shane Vitarana
+Copyright (c) 2007 Walter Korman
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'hoe'
+require 'lib/youtube_g'
+
+Hoe.new('youtube-g', YouTubeG::VERSION) do |p|
+  p.rubyforge_name = 'youtube-g'
+  p.author = ["Shane Vitarana", "Walter Korman"]
+  p.email = 'shanev@gmail.com'
+  p.summary = 'Ruby client for the YouTube GData API'
+  p.description = p.paragraphs_of('README.txt', 2..8).join("\n\n")
+  p.url = 'http://rubyforge.org/projects/youtube-g/'
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+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

data/TODO.txt

@@ -0,0 +1,11 @@
+[ ] Tests with mocked out YouTube server
+[ ] Clean up tests using Shoulda to define contexts
+[ ] Consolidate requires
+[ ] Allow :category and :categories for query DSL
+
+== API Features TODO
+
+[ ] Profile feed parsing
+[ ] Playlist feeds
+[ ] User subscriptions
+[ ] Video comments

data/lib/youtube_g.rb

@@ -0,0 +1,18 @@
+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/video_search'
+require File.dirname(__FILE__) + '/youtube_g/response/video_search'
+
+class YouTubeG
+  VERSION = '0.4.0'
+end

data/lib/youtube_g/client.rb

@@ -0,0 +1,35 @@
+require 'logger'
+
+class YouTubeG
+  class Client
+    attr_accessor :logger
+    
+    def initialize(logger=Logger.new(STDOUT))
+      @logger = logger
+    end
+
+    # Params can be one of :most_viewed, :top_rated, :recently_featured, :watch_on_mobile
+    # Or :tags, :categories, :query, :user
+    def videos_by(params, options={})
+      if params.respond_to?(:to_hash) and not params[:user]
+        request = YouTubeG::Request::VideoSearch.new(params)
+
+      elsif (params.respond_to?(:to_hash) && params[:user]) || (params == :favorites)
+        request = YouTubeG::Request::UserSearch.new(params, options)
+
+      else
+        request = YouTubeG::Request::StandardSearch.new(params, options)
+      end
+      
+      logger.debug "Submitting request [url=#{request.url}]."
+      parser = YouTubeG::Parser::VideosFeedParser.new(request.url)
+      parser.parse
+    end
+    
+    def video_by(video_id)
+      parser = YouTubeG::Parser::VideoFeedParser.new(video_id)
+      parser.parse
+    end
+    
+  end
+end

data/lib/youtube_g/logger.rb

@@ -0,0 +1,27 @@
+require 'logger'
+
+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/lib/youtube_g/model/author.rb

@@ -0,0 +1,8 @@
+class YouTubeG
+  module Model
+    class Author < YouTubeG::Record
+      attr_reader :name
+      attr_reader :uri
+    end
+  end
+end

data/lib/youtube_g/model/category.rb

@@ -0,0 +1,8 @@
+class YouTubeG
+  module Model
+    class Category < YouTubeG::Record
+      attr_reader :label
+      attr_reader :term
+    end
+  end
+end

data/lib/youtube_g/model/contact.rb

@@ -0,0 +1,8 @@
+class YouTubeG
+  module Model
+    class Contact < YouTubeG::Record
+      attr_reader :status
+      attr_reader :username
+    end
+  end
+end

data/lib/youtube_g/model/content.rb

@@ -0,0 +1,13 @@
+class YouTubeG
+  module Model
+    class Content < YouTubeG::Record
+      attr_reader :default
+      attr_reader :duration
+      attr_reader :format
+      attr_reader :mime_type
+      attr_reader :url
+      
+      alias :is_default? :default
+    end
+  end
+end

data/lib/youtube_g/model/playlist.rb

@@ -0,0 +1,7 @@
+class YouTubeG
+  module Model
+    class Playlist < YouTubeG::Record
+      attr_reader :description
+    end
+  end
+end

data/lib/youtube_g/model/rating.rb

@@ -0,0 +1,10 @@
+class YouTubeG
+  module Model
+    class Rating < YouTubeG::Record
+      attr_reader :average
+      attr_reader :max
+      attr_reader :min
+      attr_reader :rater_count
+    end
+  end
+end

data/lib/youtube_g/model/thumbnail.rb

@@ -0,0 +1,10 @@
+class YouTubeG
+  module Model
+    class Thumbnail < YouTubeG::Record
+      attr_reader :url
+      attr_reader :height
+      attr_reader :width
+      attr_reader :time
+    end
+  end
+end

data/lib/youtube_g/model/user.rb

@@ -0,0 +1,20 @@
+class YouTubeG
+  module Model
+    class User < YouTubeG::Record
+      attr_reader :age
+      attr_reader :books
+      attr_reader :company
+      attr_reader :gender
+      attr_reader :hobbies
+      attr_reader :hometown
+      attr_reader :location
+      attr_reader :movies
+      attr_reader :music
+      attr_reader :occupation
+      attr_reader :relationship
+      attr_reader :school
+      attr_reader :description
+      attr_reader :username
+    end
+  end
+end

data/lib/youtube_g/model/video.rb

@@ -0,0 +1,100 @@
+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
+
+        def initialize(format_code, name)
+          @format_code = format_code
+          @name = name
+
+          @@formats[format_code] = self          
+        end
+
+        def self.by_code(format_code)
+          @@formats[format_code]
+        end
+
+        # 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 = 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)
+      end
+
+      attr_reader :duration
+      attr_reader :noembed
+      attr_reader :position
+      attr_reader :racy
+      attr_reader :statistics
+      
+      attr_reader :video_id
+      attr_reader :published_at
+      attr_reader :updated_at
+      attr_reader :categories
+      attr_reader :keywords
+      attr_reader :title
+      attr_reader :html_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.
+      attr_reader :media_content
+
+      attr_reader :thumbnails         # YouTubeG::Model::Thumbnail records
+      attr_reader :player_url
+      attr_reader :rating
+      attr_reader :view_count
+
+      # TODO:
+      # self atom feed
+      # alternate youtube watch url
+      # responses feed
+      # related feed
+      # comments feedLink
+      
+      # 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
+      def unique_id
+        video_id.match(/videos\/([^<]+)/).captures.first
+      end
+      
+      def can_embed?
+        not @noembed
+      end
+      
+      def default_media_content
+        @media_content.find { |c| c.is_default? }
+      end
+      
+      def embed_html(width = 425, height = 350)
+        <<EDOC
+<object width="#{width}" height="#{height}">
+  <param name="movie" value="#{embed_url}"></param>
+  <param name="wmode" value="transparent"></param>
+  <embed src="#{embed_url}" type="application/x-shockwave-flash" 
+   wmode="transparent" width="#{width}" height="#{height}"></embed>
+</object>
+EDOC
+      end
+
+      def embed_url
+        @player_url.sub('watch?', '').sub('=', '/')          
+      end
+      
+    end
+  end
+end

data/lib/youtube_g/parser.rb

@@ -0,0 +1,163 @@
+require 'cgi'
+require 'open-uri'
+require 'rexml/document'
+
+class YouTubeG
+  module Parser
+    class FeedParser
+      def initialize(url)
+        @url = url
+      end
+      
+      def parse
+        parse_content open(@url).read
+      end      
+    end
+
+    class VideoFeedParser < FeedParser
+      
+      def parse_content(content)
+        doc = REXML::Document.new(content)
+        entry = doc.elements["entry"]
+        
+        parse_entry(entry)
+      end
+
+    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)
+
+        # parse the category and keyword lists
+        categories = []
+        keywords = []
+        entry.elements.each("category") do |category|
+          # determine if  it's really a category, or just a keyword
+          scheme = category.attributes["scheme"]
+          if (scheme =~ /\/categories\.cat$/)
+            # it's a category
+            categories << YouTubeG::Model::Category.new(
+                            :term => category.attributes["term"],
+                            :label => category.attributes["label"])
+
+          elsif (scheme =~ /\/keywords\.cat$/)
+            # it's a keyword
+            keywords << category.attributes["term"]
+          end
+        end
+
+        title = entry.elements["title"].text
+        html_content = entry.elements["content"].text
+
+        # parse the author
+        author_element = entry.elements["author"]
+        author = nil
+        if author_element
+          author = YouTubeG::Model::Author.new(
+                     :name => author_element.elements["name"].text,
+                     :uri => author_element.elements["uri"].text)
+        end
+      
+        media_group = entry.elements["media:group"]
+        description = media_group.elements["media:description"].text
+        duration = media_group.elements["yt:duration"].attributes["seconds"].to_i
+
+        media_content = []
+        media_group.elements.each("media:content") do |mce|
+          media_content << parse_media_content(mce)
+        end
+
+        player_url = media_group.elements["media:player"].attributes["url"]
+
+        # parse thumbnails
+        thumbnails = []
+        media_group.elements.each("media:thumbnail") do |thumb_element|
+          # TODO: convert time HH:MM:ss string to seconds?
+          thumbnails << YouTubeG::Model::Thumbnail.new(
+                          :url => thumb_element.attributes["url"],
+                          :height => thumb_element.attributes["height"].to_i,
+                          :width => thumb_element.attributes["width"].to_i,
+                          :time => thumb_element.attributes["time"])
+        end
+
+        rating_element = entry.elements["gd:rating"]
+        rating = nil
+        if rating_element
+          rating = YouTubeG::Model::Rating.new(
+                     :min => rating_element.attributes["min"].to_i,
+                     :max => rating_element.attributes["max"].to_i,
+                     :rater_count => rating_element.attributes["numRaters"].to_i,
+                     :average => rating_element.attributes["average"].to_f)
+        end
+
+        view_count = entry.elements["yt:statistics"].attributes["viewCount"].to_i
+
+        noembed = entry.elements["yt:noembed"] ? true : false
+
+        YouTubeG::Model::Video.new(
+          :video_id => video_id,
+          :published_at => published_at,
+          :updated_at => updated_at,
+          :categories => categories,
+          :keywords => keywords,
+          :title => title,
+          :html_content => html_content,
+          :author => author,
+          :description => description,
+          :duration => duration,
+          :media_content => media_content,
+          :player_url => player_url,
+          :thumbnails => thumbnails,
+          :rating => rating,
+          :view_count => view_count,
+          :noembed => noembed)
+      end
+
+      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)
+        duration = media_content_element.attributes["duration"].to_i
+        mime_type = media_content_element.attributes["type"]
+        default = (media_content_element.attributes["isDefault"] == "true")
+
+        YouTubeG::Model::Content.new(
+          :url => content_url,
+          :format => format,
+          :duration => duration,
+          :mime_type => mime_type,
+          :default => default)
+      end      
+    end
+
+    class VideosFeedParser < VideoFeedParser
+
+    private
+      def parse_content(content)
+        doc = REXML::Document.new(content)
+        feed = doc.elements["feed"]
+
+        feed_id = feed.elements["id"].text
+        updated_at = Time.parse(feed.elements["updated"].text)
+        total_result_count = feed.elements["openSearch:totalResults"].text.to_i
+        offset = feed.elements["openSearch:startIndex"].text.to_i
+        max_result_count = feed.elements["openSearch:itemsPerPage"].text.to_i
+
+        videos = []
+        feed.elements.each("entry") do |entry|
+          videos << parse_entry(entry)
+        end
+
+        YouTubeG::Response::VideoSearch.new(
+          :feed_id => feed_id,
+          :updated_at => updated_at,
+          :total_result_count => total_result_count,
+          :offset => offset,
+          :max_result_count => max_result_count,
+          :videos => videos)
+      end
+    end
+    
+  end 
+end

data/lib/youtube_g/record.rb

@@ -0,0 +1,12 @@
+class YouTubeG
+  class Record
+    def initialize (params)
+      return if params.nil?
+
+      params.each do |key, value| 
+        name = key.to_s
+        instance_variable_set("@#{name}", value) if respond_to?(name)
+      end
+    end
+  end
+end

data/lib/youtube_g/request/video_search.rb

@@ -0,0 +1,162 @@
+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
+      # From here: http://code.google.com/apis/youtube/reference.html#yt_format
+      ONLY_EMBEDDABLE = 5
+
+      attr_reader :max_results                     # max_results
+      attr_reader :order_by                        # orderby, ([relevance], viewCount)
+      attr_reader :offset                          # start-index
+      attr_reader :query                           # vq
+      attr_reader :response_format                 # alt, ([atom], rss, json)
+      attr_reader :tags                            # /-/tag1/tag2
+      attr_reader :categories                      # /-/Category1/Category2
+      attr_reader :video_format                    # format (1=mobile devices)
+      
+      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
+        # automatically fall back to the youtube api defaults
+        @max_results = nil
+        @order_by = nil
+        @offset = nil
+        @query = nil
+        @response_format = nil
+        @video_format = nil
+
+        # build up the url corresponding to this request
+        @url = base_url
+        
+        # http://gdata.youtube.com/feeds/videos/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
+        
+        if( params[ :only_embeddable ] )
+          @video_format = ONLY_EMBEDDABLE
+        end
+
+        @url << build_query_params(to_youtube_params)
+      end
+      
+      def base_url
+        super << "videos"
+      end
+      
+      def to_youtube_params
+        {
+          'max-results' => @max_results,
+          'orderby' => @order_by,
+          'start-index' => @offset,
+          'vq' => @query,
+          'alt' => @response_format,
+          'format' => @video_format
+        }
+      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
+        end
+        
+    end
+  end
+end

data/lib/youtube_g/response/video_search.rb

@@ -0,0 +1,23 @@
+class YouTubeG
+  module Response
+    class VideoSearch < YouTubeG::Record
+      # the unique feed identifying url
+      attr_reader :feed_id
+      
+      # the number of results per page
+      attr_reader :max_result_count
+      
+      # the 1-based offset index into the full result set
+      attr_reader :offset
+      
+      # the 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
+      attr_reader :updated_at
+
+      # the list of Video records
+      attr_reader :videos
+    end
+  end
+end

data/test/test_client.rb

@@ -0,0 +1,216 @@
+require 'rubygems'
+require 'test/unit'
+require 'pp'
+
+require 'youtube_g'
+
+class TestClient < Test::Unit::TestCase
+  def setup
+    @client = YouTubeG::Client.new
+  end
+
+  def test_should_respond_to_a_basic_query
+    response = @client.videos_by(:query => "penguin")
+  
+    assert_equal "http://gdata.youtube.com/feeds/api/videos", response.feed_id
+    assert_equal 25, response.max_result_count
+    assert_equal 24, response.videos.length
+    assert_equal 1, response.offset
+    assert(response.total_result_count > 100)
+    assert_instance_of Time, response.updated_at
+  
+    response.videos.each { |v| assert_valid_video v }
+  end
+  
+  def test_should_get_videos_for_multiword_metasearch_query
+    response = @client.videos_by(:query => 'christina ricci')
+  
+    assert_equal "http://gdata.youtube.com/feeds/api/videos", response.feed_id
+    assert_equal 25, response.max_result_count
+    assert_equal 25, response.videos.length
+    assert_equal 1, response.offset
+    assert(response.total_result_count > 100)
+    assert_instance_of Time, response.updated_at
+  
+    response.videos.each { |v| assert_valid_video v }
+  end
+  
+  # TODO: this doesn't work because the returned feed is in an unknown format
+  # def test_should_get_video_for_search_by_video_id
+  #   response = @client.videos_by(:video_id => "T7YazwP8GtY")
+  #   response.videos.each { |v| assert_valid_video v }    
+  # end
+  
+  def test_should_get_videos_for_one_tag
+    response = @client.videos_by(:tags => ['panther'])
+    response.videos.each { |v| assert_valid_video v }
+  end
+  
+  def test_should_get_videos_for_multiple_tags
+    response = @client.videos_by(:tags => ['tiger', 'leopard'])
+    response.videos.each { |v| assert_valid_video v }    
+  end
+  
+  def test_should_get_videos_for_one_category
+    response = @client.videos_by(:categories => [:news])
+    response.videos.each { |v| assert_valid_video v }    
+  end
+  
+  def test_should_get_videos_for_multiple_categories
+    response = @client.videos_by(:categories => [:news, :sports])
+    response.videos.each { |v| assert_valid_video v }        
+  end
+  
+  # TODO: Need to do more specific checking in these tests
+  # Currently, if a URL is valid, and videos are found, the test passes regardless of search criteria
+  def test_should_get_videos_for_categories_and_tags
+    response = @client.videos_by(:categories => [:news, :sports], :tags => ['soccer', 'football'])
+    response.videos.each { |v| assert_valid_video v }            
+  end
+  
+  def test_should_get_most_viewed_videos
+    response = @client.videos_by(:most_viewed)
+    response.videos.each { |v| assert_valid_video v }                
+  end
+  
+  def test_should_get_top_rated_videos_for_today
+    response = @client.videos_by(:top_rated, :time => :today)
+    response.videos.each { |v| assert_valid_video v }                    
+  end
+  
+  def test_should_get_videos_for_categories_and_tags_with_category_boolean_operators
+    response = @client.videos_by(:categories => { :either => [:news, :sports], :exclude => [:comedy] },
+                                 :tags => { :include => ['football'], :exclude => ['soccer'] })
+    response.videos.each { |v| assert_valid_video v }
+  end
+
+  def test_should_get_videos_for_categories_and_tags_with_tag_boolean_operators
+    response = @client.videos_by(:categories => { :either => [:news, :sports], :exclude => [:comedy] },
+                                 :tags => { :either => ['football', 'soccer', 'polo'] })
+    response.videos.each { |v| assert_valid_video v }
+  end
+  
+  def test_should_get_videos_by_user
+    response = @client.videos_by(:user => 'liz')
+    response.videos.each { |v| assert_valid_video v }
+  end
+
+  # HTTP 403 Error
+  # def test_should_get_favorite_videos_by_user
+  #   response = @client.videos_by(:favorites, :user => 'liz')
+  #   response.videos.each { |v| assert_valid_video v }
+  # 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/wOnP_oAXUMA\"></param>\n  <param name=\"wmode\" value=\"transparent\"></param>\n  <embed src=\"http://www.youtube.com/v/wOnP_oAXUMA\" 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
+  end
+
+  def test_should_create_logger_if_not_passed_in
+    @client = YouTubeG::Client.new
+    assert_not_nil @client.logger
+  end
+  
+  def test_should_determine_if_nonembeddable_video_is_embeddable
+    response = @client.videos_by(:query => "avril lavigne girlfriend")
+  
+    video = response.videos.first
+    assert !video.can_embed?
+  end
+
+  def test_should_determine_if_embeddable_video_is_embeddable
+    response = @client.videos_by(:query => "strongbad")
+  
+    video = response.videos.first
+    assert video.can_embed?
+  end
+  
+  def test_should_retrieve_video_by_id
+    video = @client.video_by("http://gdata.youtube.com/feeds/videos/EkF4JD2rO3Q")
+    assert_valid_video video
+  end
+  
+  private
+
+    def assert_valid_video (video)
+      # pp video
+
+      # check general attributes
+      assert_instance_of YouTubeG::Model::Video, video
+      assert_instance_of Fixnum, video.duration
+      assert(video.duration > 0)
+      #assert_match(/^<div style=.*?<\/div>/m, video.html_content)
+      assert_instance_of String, video.html_content
+
+      # validate media content records
+      video.media_content.each do |media_content|
+        # http://www.youtube.com/v/IHVaXG1thXM
+        assert_valid_url media_content.url
+        assert(media_content.duration > 0)
+        assert_instance_of YouTubeG::Model::Video::Format, media_content.format
+        assert_instance_of String, media_content.mime_type
+        assert_match(/^[^\/]+\/[^\/]+$/, media_content.mime_type)
+      end
+
+      default_content = video.default_media_content
+      if default_content
+        assert_instance_of YouTubeG::Model::Content, default_content
+        assert default_content.is_default?
+      end
+
+      # validate keywords
+      video.keywords.each { |kw| assert_instance_of(String, kw) }
+
+      # http://www.youtube.com/watch?v=IHVaXG1thXM
+      assert_valid_url video.player_url
+      assert_instance_of Time, video.published_at
+
+      # validate optionally-present rating
+      if video.rating
+        assert_instance_of YouTubeG::Model::Rating, video.rating
+        assert_instance_of Float, video.rating.average
+        assert_instance_of Fixnum, video.rating.max
+        assert_instance_of Fixnum, video.rating.min
+        assert_instance_of Fixnum, video.rating.rater_count
+      end
+      
+      # validate thumbnails
+      assert(video.thumbnails.size > 0)
+
+      assert_not_nil video.title
+      assert_instance_of String, video.title
+      assert(video.title.length > 0)
+
+      assert_instance_of Time, video.updated_at
+      # http://gdata.youtube.com/feeds/videos/IHVaXG1thXM
+      assert_valid_url video.video_id
+      assert_instance_of Fixnum, video.view_count
+
+      # validate author
+      assert_instance_of YouTubeG::Model::Author, video.author
+      assert_instance_of String, video.author.name
+      assert(video.author.name.length > 0)
+      assert_valid_url video.author.uri
+      
+      # validate categories
+      video.categories.each do |cat|
+        assert_instance_of YouTubeG::Model::Category, cat
+        assert_instance_of String, cat.label
+        assert_instance_of String, cat.term
+      end
+    end
+
+    def assert_valid_url (url)
+      URI::parse(url)
+      return true
+    rescue
+      return false
+    end
+end

data/test/test_video.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'test/unit'
+require 'pp'
+
+require 'youtube_g'
+
+class TestVideo < Test::Unit::TestCase
+
+  def test_should_extract_unique_id_from_video_id
+    video = YouTubeG::Model::Video.new(:video_id => "http://gdata.youtube.com/feeds/videos/ZTUVgYoeN_o")
+    assert_equal "ZTUVgYoeN_o", video.unique_id
+  end
+
+  def test_should_extract_unique_id_with_hypen_from_video_id
+    video = YouTubeG::Model::Video.new(:video_id => "http://gdata.youtube.com/feeds/videos/BDqs-OZWw9o")
+    assert_equal "BDqs-OZWw9o", video.unique_id
+  end
+end

data/test/test_video_search.rb

@@ -0,0 +1,114 @@
+require 'rubygems'
+require 'test/unit'
+require 'pp'
+
+require 'youtube_g'
+
+class TestVideoSearch < Test::Unit::TestCase
+
+  def test_should_build_basic_query_url
+    request = YouTubeG::Request::VideoSearch.new(:query => "penguin")
+    assert_equal "http://gdata.youtube.com/feeds/api/videos?vq=penguin", request.url
+  end
+  
+  def test_should_build_multiword_metasearch_query_url
+    request = YouTubeG::Request::VideoSearch.new(:query => 'christina ricci')
+    assert_equal "http://gdata.youtube.com/feeds/api/videos?vq=christina+ricci", request.url
+  end
+  
+  def test_should_build_video_id_url
+    request = YouTubeG::Request::VideoSearch.new(:video_id => 'T7YazwP8GtY')
+    assert_equal "http://gdata.youtube.com/feeds/api/videos/T7YazwP8GtY", request.url
+  end
+
+  def test_should_build_one_tag_querl_url
+    request = YouTubeG::Request::VideoSearch.new(:tags => ['panther'])
+    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/panther/", request.url
+  end
+  
+  def test_should_build_multiple_tags_query_url
+    request = YouTubeG::Request::VideoSearch.new(:tags => ['tiger', 'leopard'])
+    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/tiger/leopard/", request.url
+  end
+  
+  def test_should_build_one_category_query_url
+    request = YouTubeG::Request::VideoSearch.new(:categories => [:news])
+    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/News/", request.url
+  end
+  
+  def test_should_build_multiple_categories_query_url
+    request = YouTubeG::Request::VideoSearch.new(:categories => [:news, :sports])
+    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/News/Sports/", request.url
+  end
+  
+  def test_should_build_categories_and_tags_query_url
+    request = YouTubeG::Request::VideoSearch.new(:categories => [:news, :sports], :tags => ['soccer', 'football'])
+    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/News/Sports/soccer/football/", request.url
+  end
+  
+  def test_should_build_categories_and_tags_url_with_max_results
+    request = YouTubeG::Request::VideoSearch.new(:categories => [:music], :tags => ['classic', 'rock'], :max_results => 2)
+    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/Music/classic/rock/?max-results=2", request.url
+  end
+  
+  # -- Standard Feeds --------------------------------------------------------------------------------
+  
+  def test_should_build_url_for_most_viewed
+    request = YouTubeG::Request::StandardSearch.new(:most_viewed)
+    assert_equal "http://gdata.youtube.com/feeds/api/standardfeeds/most_viewed", 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 -------------------------------------------------------------------------
+  
+  def test_should_build_url_for_boolean_or_case_for_categories
+    request = YouTubeG::Request::VideoSearch.new(:categories => { :either => [:news, :sports] })
+    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/News%7CSports/", request.url
+  end
+
+  def test_should_build_url_for_boolean_or_and_exclude_case_for_categories
+    request = YouTubeG::Request::VideoSearch.new(:categories => { :either => [:news, :sports], :exclude => [:comedy] })
+    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/News%7CSports/-Comedy/", request.url
+  end
+
+  def test_should_build_url_for_exclude_case_for_tags
+    request = YouTubeG::Request::VideoSearch.new(:categories => { :either => [:news, :sports], :exclude => [:comedy] },
+                                                 :tags => { :include => ['football'], :exclude => ['soccer'] })
+    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/News%7CSports/-Comedy/football/-soccer/", request.url
+  end
+
+  def test_should_build_url_for_either_case_for_tags
+    request = YouTubeG::Request::VideoSearch.new(:categories => { :either => [:news, :sports], :exclude => [:comedy] },
+                                                 :tags => { :either => ['soccer', 'football', 'donkey'] })
+    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/News%7CSports/-Comedy/soccer%7Cfootball%7Cdonkey/", request.url
+  end
+  
+  def test_should_build_url_for_query_search_with_categories_excluded
+    request = YouTubeG::Request::VideoSearch.new(:query => 'bench press', 
+                                                 :categories => { :exclude => [:comedy, :entertainment] },
+                                                 :max_results => 10)
+    assert_equal "http://gdata.youtube.com/feeds/api/videos/-/-Comedy/-Entertainment/?vq=bench+press&max-results=10", request.url
+  end
+  
+  # -- User Queries ---------------------------------------------------------------------------------
+  
+  def test_should_build_url_for_videos_by_user
+    request = YouTubeG::Request::UserSearch.new(:user => 'liz')
+    assert_equal "http://gdata.youtube.com/feeds/api/users/liz/uploads", request.url
+  end
+  
+  def test_should_build_url_for_favorite_videos_by_user
+    request = YouTubeG::Request::UserSearch.new(:favorites, :user => 'liz')
+    assert_equal "http://gdata.youtube.com/feeds/api/users/liz/favorites", request.url
+  end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: youtube-g
+version: !ruby/object:Gem::Version 
+  version: 0.4.0
+date: 2007-12-18 00:00:00 -06:00
+summary: Ruby client for the YouTube GData API
+require_paths: 
+- lib
+email: shanev@gmail.com
+homepage: http://rubyforge.org/projects/youtube-g/
+rubyforge_project: youtube-g
+description: "== FEATURES/PROBLEMS:  * Aims to be in parity with Google's YouTube GData API (it is currently not complete)  == SYNOPSIS:  Basic queries:  @client = YouTubeG::Client.new @client.videos_by(:query => \"penguin\") @client.videos_by(:tags => ['tiger', 'leopard']) @client.videos_by(:categories => [:news, :sports]) @client.videos_by(:categories => [:news, :sports], :tags => ['soccer', 'football']) @client.videos_by(:user => 'liz')  Standard feeds:  @client.videos_by(:most_viewed) @client.videos_by(:top_rated, :time => :today)  Advanced queries (with boolean operators OR (either), AND (include), NOT (exclude)):  @client.videos_by(:categories => { :either => [:news, :sports], :exclude => [:comedy] }, :tags => { :include => ['football'], :exclude => ['soccer'] })  == REQUIREMENTS:  * None  == INSTALL:  * sudo gem install youtube-g"
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Shane Vitarana
+- Walter Korman
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- TODO.txt
+- lib/youtube_g.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
+- 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/video_search.rb
+- lib/youtube_g/response/video_search.rb
+- test/test_client.rb
+- test/test_video.rb
+- test/test_video_search.rb
+test_files: 
+- test/test_client.rb
+- test/test_video.rb
+- test/test_video_search.rb
+rdoc_options: 
+- --main
+- README.txt
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- TODO.txt
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.3.0
+    version: