youtube 0.8.5 → 0.8.6

data/CHANGELOG

@@ -1,3 +1,20 @@
+* 2007/06/12
+
+- [shaper] Fixed typo in VideoDetails, recoding -> recording
+- [cardmagic] Changed URI.encode to CGI.escape to properly encode &
+- [shaper] Test for character encoding
+- [drummr77] Force XML parsed empty strings to be Strings and not Hashes
+	Discovered by shaper.
+- [Rob Tsuk] Added paging support to videos_by_user
+- [Rob Tsuk] Created test YouTube account for running tests
+- [Thomas Cox] Added support for the embed_status tag
+
+* 2007/06/11
+
+- [drummr77] Removed videos_by_category since it was removed by YouTube.
+- [drummr77] Renamed videos_by_category_and_tag to videos_by_category_id_and_tag.
+- [drummr77] Added videos_by_category_and_tag taking in a category name and tag
+
 * 2007/02/12
 
 - [drummr77] Added fix to check if returned video response contains an

data/Rakefile

@@ -6,7 +6,7 @@ require 'rake/gempackagetask'
 
 spec = Gem::Specification.new do |s|
   s.name = 'youtube'
-  s.version = '0.8.5'
+  s.version = '0.8.6'
   s.author = 'Shane Vitarana'
   s.email = 'shanev@gmail.com'
   s.platform = Gem::Platform::RUBY

data/TODO

@@ -6,9 +6,6 @@
   we're doing the Right/Best Thing.  It looks like we've got hashes with
   one key e.g. "comments" that then map to a list of actual comments.
 
-- look at what we store for fields with no actual value; appears we're
-  storing empty hashes in at least some cases.
-
 - add unit tests for client.videos_by_tag page and per_page params.
 
 - add unit tests for specifying alternate api host/path in client

data/lib/youtube.rb

@@ -22,11 +22,26 @@
 #++
 
 require 'net/http'
-require 'uri'
 require 'xmlsimple'
+require 'cgi'
 
 module YouTube
 
+  class Category
+    FILMS_ANIMATION = 1
+    AUTOS_VEHICLES = 2
+    COMEDY = 23
+    ENTERTAINMENT = 24
+    MUSIC = 10
+    NEWS_POLITICS = 25
+    PEOPLE_BLOGS = 22
+    PETS_ANIMALS = 15
+    HOWTO_DIY = 26
+    SPORTS = 17
+    TRAVEL_PLACES = 19
+    GADGETS_GAMES = 20    
+  end
+  
   # Main client class managing all interaction with the YouTube server.
   # Server communication is handled via method_missing() emulating an
   # RPC-like call and performing all of the work to send out the HTTP
@@ -37,7 +52,7 @@ module YouTube
     DEFAULT_HOST = 'http://www.youtube.com'
     # the default api path to the YouTube API
     DEFAULT_API_PATH = '/api2_rest'
-
+    
     def initialize(dev_id = nil, host = DEFAULT_HOST, api_path = DEFAULT_API_PATH)
       raise "developer id required" unless dev_id
 
@@ -79,8 +94,8 @@ module YouTube
       _parse_video_response(response)
     end
 
-    # Returns a list of YouTube::Video objects that match any of the
-    # specified +tag+s.
+    # Returns a list of YouTube::Video objects that match the
+    # specified +tag+.
     #
     # Optional parameters are:
     # +page+ = the "page" of results to retrieve (e.g. 1, 2, 3)
@@ -91,7 +106,7 @@ module YouTube
     end
 
     # Returns a list of YouTube::Video objects with the specified
-    # +playlist id+.
+    # playlist +id+.
     #
     # Optional parameters are:
     # +page+ = the "page" of results to retrieve (e.g. 1, 2, 3)
@@ -101,35 +116,52 @@ module YouTube
       _parse_video_response(response)
     end
 
-    # Returns a list of YouTube::Video objects with the specified
-    # +category id+.
+    # Returns a list of YouTube::Video objects detailing the videos
+    # matching the supplied category +id+ and +tag+.
     #
     # Optional parameters are:
     # +page+ = the "page" of results to retrieve (e.g. 1, 2, 3)
     # +per_page+ = the number of results per page (default: 20, max 100).
-    def videos_by_category(id, page = 1, per_page = 20)
-      response = videos_list_by_category(:category_id => id, :page => page, :per_page => per_page)
+    def videos_by_category_id_and_tag(id, tag, page = 1, per_page = 20)
+      response = videos_list_by_category_and_tag(:category_id => id, :tag => tag, :page => page, :per_page => per_page)
       _parse_video_response(response)
     end
 
     # Returns a list of YouTube::Video objects detailing the videos
-    # matching the supplied +category id+ and +tag+.
+    # matching the supplied +category+ and +tag+.
     #
+    # Available categories:
+    # YouTube::Category::FILMS_ANIMATION
+    # YouTube::Category::AUTOS_VEHICLES
+    # YouTube::Category::COMEDY
+    # YouTube::Category::ENTERTAINMENT
+    # YouTube::Category::MUSIC
+    # YouTube::Category::NEWS_POLITICS
+    # YouTube::Category::PEOPLE_BLOGS
+    # YouTube::Category::PETS_ANIMALS
+    # YouTube::Category::HOWTO_DIY
+    # YouTube::Category::SPORTS
+    # YouTube::Category::TRAVEL_PLACES
+    # YouTube::Category::GADGETS_GAMES
+    #    
     # Optional parameters are:
     # +page+ = the "page" of results to retrieve (e.g. 1, 2, 3)
     # +per_page+ = the number of results per page (default: 20, max 100).
-    def videos_by_category_and_tag(id, tag, page = 1, per_page = 20)
-      response = videos_list_by_category_and_tag(:category_id => id, :tag => tag, :page => page, :per_page => per_page)
-      _parse_video_response(response)
+    def videos_by_category_and_tag(category, tag, page = 1, per_page = 20)
+      videos_by_category_id_and_tag(category, tag, page, per_page)
     end
 
     # Returns a list of YouTube::Video objects detailing the videos
     # uploaded by the specified +username+.
-    def videos_by_user(username)
-      response = videos_list_by_user(:user => username)
-      _parse_video_response(response)
-    end
-
+    #
+    # Optional parameters are:
+    # +page+ = the "page" of results to retrieve (e.g. 1, 2, 3)
+    # +per_page+ = the number of results per page (default: 20, max 100).
+    def videos_by_user(username, page = 1, per_page = 20)
+      response = videos_list_by_user(:user => username, :page => page, :per_page => per_page)
+       _parse_video_response(response)
+     end
+    
     # Returns a list of YouTube::Video objects detailing the current
     # global set of featured videos on YouTube.
     def featured_videos
@@ -157,18 +189,15 @@ module YouTube
 
       def _request(method, *params)
         url = _request_url(method, *params)
-        response = XmlSimple.xml_in(_http_get(url), 
-                                    { 'ForceArray' => [ 'video', 'friend' ] })
-        unless response['status'] == 'ok'
-          raise response['error']['description'] + " : url=#{url}"
-        end
+        response = XmlSimple.xml_in(_http_get(url), { 'ForceArray' => [ 'video', 'friend' ] })
+        raise response['error']['description'] + " : url=#{url}" unless response['status'] == 'ok' 
         response
       end
 
       def _request_url(method, *params)
         param_list = String.new
         unless params.empty?
-          params.first.each_pair { |k, v| param_list << "&#{k.to_s}=#{URI.encode(v.to_s)}" }
+          params.first.each_pair { |k, v| param_list << "&#{k.to_s}=#{CGI.escape(v.to_s)}" }
         end
         url = "#{@host}#{@api_path}?method=youtube.#{method}&dev_id=#{@dev_id}#{param_list}"
       end
@@ -192,7 +221,7 @@ module YouTube
     def initialize(payload)
       @favorite_count = payload['favorite_count'].to_i
       @friend_count = payload['friend_count'].to_i
-      @user = payload['user']
+      @user = payload['user'].to_s
       @video_upload_count = payload['video_upload_count'].to_i
     end        
   end
@@ -220,24 +249,24 @@ module YouTube
     attr_reader :video_watch_count
 
     def initialize(payload)
-      @about_me = payload['about_me']
+      @about_me = payload['about_me'].to_s
       @age = payload['age'].to_i
-      @books = payload['books']
-      @city = payload['city']
-      @companies = payload['companies']
-      @country = payload['country']
+      @books = payload['books'].to_s
+      @city = payload['city'].to_s
+      @companies = payload['companies'].to_s
+      @country = payload['country'].to_s
       @currently_on = YouTube._string_to_boolean(payload['currently_on'])
       @favorite_video_count = payload['favorite_video_count'].to_i
-      @first_name = payload['first_name']
+      @first_name = payload['first_name'].to_s
       @friend_count = payload['friend_count'].to_i
-      @gender = payload['gender']
-      @hobbies = payload['hobbies']
-      @homepage = payload['homepage']
-      @hometown = payload['hometown']
-      @last_name = payload['last_name']
-      @movies = payload['movies']
-      @occupations = payload['occupations']
-      @relationship = payload['relationship']
+      @gender = payload['gender'].to_s
+      @hobbies = payload['hobbies'].to_s
+      @homepage = payload['homepage'].to_s
+      @hometown = payload['hometown'].to_s
+      @last_name = payload['last_name'].to_s
+      @movies = payload['movies'].to_s
+      @occupations = payload['occupations'].to_s
+      @relationship = payload['relationship'].to_s
       @video_upload_count = payload['video_upload_count'].to_i
       @video_watch_count = payload['video_watch_count'].to_i
     end
@@ -260,16 +289,16 @@ module YouTube
     attr_reader :view_count
 
     def initialize(payload)
-      @author = payload['author']
+      @author = payload['author'].to_s
       @comment_count = payload['comment_count'].to_i
-      @description = payload['description']
+      @description = payload['description'].to_s
       @id = payload['id']
       @length_seconds = payload['length_seconds'].to_i
       @rating_avg = payload['rating_avg'].to_f
       @rating_count = payload['rating_count'].to_i
       @tags = payload['tags']
       @thumbnail_url = payload['thumbnail_url']
-      @title = payload['title']
+      @title = payload['title'].to_s
       @upload_time = YouTube._string_to_time(payload['upload_time'])
       @url = payload['url']
       @view_count = payload['view_count'].to_i
@@ -303,7 +332,7 @@ edoc
     attr_reader :length_seconds
     attr_reader :rating_avg
     attr_reader :rating_count
-    attr_reader :recoding_location
+    attr_reader :recording_location
     attr_reader :recording_country
     attr_reader :recording_date
     attr_reader :tags
@@ -312,24 +341,28 @@ edoc
     attr_reader :update_time
     attr_reader :upload_time
     attr_reader :view_count
+    attr_reader :embed_status
+    attr_reader :embed_allowed
 
     def initialize(payload)
-      @author = payload['author']
+      @author = payload['author'].to_s
       @channel_list = payload['channel_list']
       @comment_list = payload['comment_list']
-      @description = payload['description']
+      @description = payload['description'].to_s
       @length_seconds = payload['length_seconds'].to_i
       @rating_avg = payload['rating_avg'].to_f
       @rating_count = payload['rating_count'].to_i
-      @recording_country = payload['recording_country']
-      @recording_date = payload['recording_date']
-      @recording_location = payload['recording_location']
+      @recording_country = payload['recording_country'].to_s
+      @recording_date = payload['recording_date'].to_s
+      @recording_location = payload['recording_location'].to_s
       @tags = payload['tags']
       @thumbnail_url = payload['thumbnail_url']
-      @title = payload['title']
+      @title = payload['title'].to_s
       @update_time = YouTube._string_to_time(payload['update_time'])
       @upload_time = YouTube._string_to_time(payload['upload_time'])
       @view_count = payload['view_count'].to_i
+      @embed_status = payload['embed_status']
+      @embed_allowed = ( payload['embed_status'] == "ok" )
     end
   end
 
@@ -345,5 +378,5 @@ edoc
     # representing seconds since the epoch, or nil if the string is nil.
     def self._string_to_time(time_str)
       (time_str) ? Time.at(time_str.to_i) : nil
-    end
+    end    
 end

data/test/test_api.rb

@@ -2,15 +2,25 @@ require 'rubygems'
 require 'test/unit'
 require 'youtube'
 require 'pp'
+require 'yaml'
+require 'set'
 
 # This test class assumes an active internet connection
 class TestAPI < Test::Unit::TestCase
-  @@DEVELOPER_API_KEY = 'DEVELOPER_ID'
+  @@DEVELOPER_API_KEY = 'RCofu-vAmeY'
+  YOUTUBE_LIB_USERID = 'ytlibtest'
 
   def setup
     @client = YouTube::Client.new @@DEVELOPER_API_KEY
   end
 
+  # test to ensure escaping strange characters like ampersands works
+  # properly as we've been bitten by finding that they don't
+  def test_videos_by_tag_escape
+    videos = @client.videos_by_tag('cindy & margolis')
+    _test_video_list(videos)
+  end
+
   def test_profile
     profile = @client.profile('nutria42')
 
@@ -70,11 +80,34 @@ class TestAPI < Test::Unit::TestCase
   def test_videos_by_user
     # test case where videos exist
     videos = @client.videos_by_user('whytheluckystiff')
+    _test_video_list(videos)    
+  end
+  
+  def test_should_return_10_videos_for_user
+    videos = @client.videos_by_user(YOUTUBE_LIB_USERID)
     _test_video_list(videos)
-    
-    # test case where videos don't exist
-    videos = @client.videos_by_user('br0wnpunk')
-    assert_nil videos
+
+    assert_equal 10, videos.length
+    videos_seen = Set.new
+    videos.each do |video|
+      _validate_test_video(video, videos_seen)
+    end
+  end
+  
+  def test_should_paginate_videos_by_user
+    total_videos = 10
+    expected_page_size = 3
+    videos_seen = Set.new
+    1.upto(4) do |index|
+     videos = @client.videos_by_user(YOUTUBE_LIB_USERID, index, expected_page_size)
+     _test_video_list(videos)
+     expected_video_count = total_videos > expected_page_size ? expected_page_size : total_videos
+     assert_equal expected_video_count, videos.length
+     videos.each do |video|
+       _validate_test_video(video, videos_seen)
+     end
+     total_videos -= expected_page_size
+    end    
   end
 
   def test_videos_by_related
@@ -87,16 +120,27 @@ class TestAPI < Test::Unit::TestCase
     _test_video_list(videos)
   end
   
-  # def test_videos_by_category
-  #   videos = @client.videos_by_category('10')
-  #   _test_video_list(videos)
-  # end
-  # 
-  # def test_videos_by_category_and_tag
-  #   videos = @client.videos_by_category_and_tag('10', 'punk')
-  #   _test_video_list(videos)
-  # end
+  def test_videos_by_category_id_and_tag
+    videos = @client.videos_by_category_id_and_tag(17, 'bench')
+    _test_video_list(videos)
+  end
+  
+  def test_videos_by_category_and_tag
+    videos = @client.videos_by_category_and_tag(YouTube::Category::SPORTS, 'bench')
+    _test_video_list(videos)
+  end
+  
+  def test_should_not_return_any_videos_for_videos_by_category_and_tag
+    videos = @client.videos_by_category_and_tag(YouTube::Category::SPORTS, 'somerandomtagthatihopedoesntexist')
+    assert_nil videos
+  end
   
+  def test_should_get_comment_count_for_video
+    videos = @client.videos_by_tag('imogen heap hide and seek')
+    video = videos.sort{ |a,b| b.view_count <=> a.view_count }.first
+    assert video.comment_count > 0
+  end
+
   def test_featured_videos
     videos = @client.featured_videos
     _test_video_list(videos)
@@ -114,7 +158,9 @@ class TestAPI < Test::Unit::TestCase
       assert (details.author && details.author.length > 0)
       assert (details.length_seconds > 0)
       assert (details.title && details.title.length > 0)
-      assert (details.description && details.description.length > 0)
+      assert_instance_of String, details.description
+      assert details.embed_allowed if details.embed_status == "ok"
+      assert !details.embed_allowed if details.embed_status == "not allowed"
     end
 
     # make sure parameter validation is operating correctly
@@ -147,48 +193,79 @@ class TestAPI < Test::Unit::TestCase
   end
 
   private
-
-  # Returns the number of times +substr+ exists within +text+.
-  def _match_count (substr, text)
-    return 0 if (!text || !substr)
-
-    count = 0
-    offset = 0
-    while (result = text.index(substr, offset))
-      count += 1
-      offset = result + 1
+    # Returns the number of times +substr+ exists within +text+.
+    def _match_count (substr, text)
+      return 0 if (!text || !substr)
+
+      count = 0
+      offset = 0
+      while (result = text.index(substr, offset))
+        count += 1
+        offset = result + 1
+      end
+      count
     end
-    count
-  end
 
-  def _assert_youtube_url (url)
-    (url =~ /^http:\/\/www.youtube.com\//)
-  end
-
-  def _test_video_list (videos)
-    # make sure we got some videos
-    assert_not_nil videos
-    assert (videos.length > 0)
-
-    # make sure all video records look good
-    videos.each { |video| _test_video(video) }
-  end
+    def _assert_youtube_url (url)
+      (url =~ /^http:\/\/www.youtube.com\//)
+    end
 
-  def _test_video (video)
-    assert_kind_of YouTube::Video, video
+    def _test_video_list (videos)
+      # make sure we got some videos
+      assert_not_nil videos
+      assert (videos.length > 0)
 
-    # sanity-check embed url to make sure it looks ok
-    assert_not_nil video.embed_url
-    _assert_youtube_url video.embed_url
+      # make sure all video records look good
+      videos.each { |video| _test_video(video) }
+    end
 
-    # check other attributes
-    assert (video.thumbnail_url =~ /\.jpg$/)
-    assert (video.title && video.title.length > 0)
-    assert (video.length_seconds > 0)
-    assert (video.upload_time && video.upload_time.is_a?(Time))
-    _assert_youtube_url video.url
-    assert (video.view_count >= 0)
-    assert (video.tags && video.tags.length > 0)
-    assert (video.author && video.author.length > 0)
-  end
+    def _test_video (video)
+      assert_kind_of YouTube::Video, video
+
+      # sanity-check embed url to make sure it looks ok
+      assert_not_nil video.embed_url
+      _assert_youtube_url video.embed_url
+
+      # check other attributes
+      assert (video.thumbnail_url =~ /\.jpg$/)
+      assert (video.title && video.title.length > 0)
+      assert (video.length_seconds > 0)
+      # make sure description came through as a string, as a single check
+      # that we feel good about covering other fields since the xml parsing
+      # of empty elements defaults to providing an empty hash but we want
+      # a proper type everywhere.
+      assert_instance_of String, video.description
+      assert (video.upload_time && video.upload_time.is_a?(Time))
+      _assert_youtube_url video.url
+      assert (video.view_count >= 0)
+      assert (video.tags && video.tags.length > 0)
+      assert (video.author && video.author.length > 0)
+    end
+  
+    def _validate_test_video(video, videos_seen = nil)
+      values = YAML.load(video.description)
+      index = values["index"]
+    
+      # make sure we only see a particular video once
+      # if the particular test cares about that
+      if videos_seen
+        assert !videos_seen.include?(index)
+        videos_seen.add(index)
+      end
+    
+      title = sprintf("Test Video %02d", index)
+      assert_equal title, video.title
+      assert_equal values["length"], video.length_seconds
+    
+      tags = Set.new(video.tags.split)
+      if index.modulo(2) == 1
+        assert tags.include?("ytlodd")
+      else
+        assert tags.include?("ytleven")
+      end
+    
+      if [2,3,5,7].to_set.include?(index)
+        assert tags.include?("ytlprime")
+      end
+    end
 end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11
+rubygems_version: 0.9.4
 specification_version: 1
 name: youtube
 version: !ruby/object:Gem::Version 
-  version: 0.8.5
-date: 2007-02-12 00:00:00 -06:00
+  version: 0.8.6
+date: 2007-06-12 00:00:00 -04:00
 summary: A Ruby object-oriented interface to the YouTube REST API.
 require_paths: 
 - lib
@@ -25,6 +25,7 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
 platform: ruby
 signing_key: 
 cert_chain: 
+post_install_message: 
 authors: 
 - Shane Vitarana
 files: