natedaiger-youtube-g 0.5.1 → 0.6.0

data/README.txt

@@ -54,6 +54,11 @@ Standard feeds:
 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'] })
+  
+Comment feeds for videos:
+  client.comments_for('some_youtube_id').comments
+  video = client.video_by('some_youtube_id')
+  video.comments_seach(:page => 2, :per_page => 12).comments
 
 == LOGGING
 

data/lib/youtube_g.rb

@@ -50,6 +50,7 @@ end
   parser
   model/author
   model/category
+  model/comment
   model/contact
   model/content
   model/playlist
@@ -58,10 +59,12 @@ end
   model/user
   model/video
   request/base_search
+  request/comments_search
   request/user_search
   request/standard_search
   request/video_upload
   request/video_search
+  response/comments_search
   response/video_search
   chain_io
 ).each{|m| require File.dirname(__FILE__) + '/youtube_g/' + m }

data/lib/youtube_g/client.rb

@@ -70,6 +70,21 @@ class YouTubeG
       parser = YouTubeG::Parser::VideoFeedParser.new(video_id)
       parser.parse
     end
+
+    # Retrieves a single YouTube video.
+    #
+    # === Parameters
+    #   vid<String>:: The ID of the video whose contents you'd like to retrieve
+    #
+    #   options<Hash> (optional)::  Accepts the options of :page (default is 1), 
+    #                               and :per_page (default is 25). :offset and :max_results
+    #                               can also be passed for a custom offset.
+    # === Returns
+    # YouTubeG::Response::CommentsSearch
+    def comments_for(vid, options={})
+      url = YouTubeG::Request::CommentsSearch.new(vid, options).url
+      YouTubeG::Parser::CommentsFeedParser.new(url).parse
+    end
     
     private
     

data/lib/youtube_g/model/video.rb

@@ -136,6 +136,16 @@ class YouTubeG
       def responses
         YouTubeG::Parser::VideosFeedParser.new("http://gdata.youtube.com/feeds/api/videos/#{unique_id}/responses").parse
       end
+
+      # Comments on the current video.
+      #
+      # === Returns
+      #   YouTubeG::Response::CommentsSearch
+      def comments_search(options={})
+        url = YouTubeG::Request::CommentsSearch.new(unique_id,options).url
+        YouTubeG::Parser::CommentsFeedParser.new(url).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.

data/lib/youtube_g/parser.rb

@@ -21,6 +21,23 @@ class YouTubeG
     protected
       def parse_entry(entry) 
         video_id = entry.elements["id"].text
+        
+        if entry.elements["app:control/yt:state"]          
+          # yt:state generally indicates a video is unavailable
+          # see: http://code.google.com/apis/youtube/2.0/reference.html#youtube_data_api_tag_yt:state
+          unless entry.elements["app:control/yt:state[@name='restricted']"]
+            # the exception I've found is for *restricted* videos, which generally
+            # means they're not available for viewing on a device other than a web browser
+            # or in a certain region
+            return nil
+          end
+        end
+        
+        # if there's no content we're going to puke later
+        unless entry.elements['content']
+          return nil
+        end
+        
         published_at = Time.parse(entry.elements["published"].text)
         updated_at = Time.parse(entry.elements["updated"].text)
 
@@ -157,7 +174,9 @@ class YouTubeG
 
         videos = []
         feed.elements.each("entry") do |entry|
-          videos << parse_entry(entry)
+          if video = parse_entry(entry)
+            videos << video
+          end
         end
 
         YouTubeG::Response::VideoSearch.new(
@@ -169,6 +188,60 @@ class YouTubeG
           :videos => videos)
       end
     end
+
+    class CommentsFeedParser < FeedParser
     
+      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
+        
+        comments = []
+        feed.elements.each('entry') do |entry|
+          comments << parse_entry(entry)
+        end
+        YouTubeG::Response::CommentsSearch.new(
+          :feed_id            => feed_id,
+          :updated_at         => updated_at,
+          :total_result_count => total_result_count,
+          :offset             => offset,
+          :max_result_count   => max_result_count,
+          :comments           => comments)
+      end
+      
+    private
+      def parse_entry(entry)
+        comment_id = entry.elements["id"].text
+        
+        published_at = Time.parse(entry.elements["published"].text)
+        updated_at   = Time.parse(entry.elements["updated"].text)
+
+        title   = entry.elements["title"].text
+        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
+      
+
+        comment = YouTubeG::Model::Comment.new(
+          :published_at => published_at,
+          :updated_at   => updated_at,
+          :title        => title,
+          :content      => content,
+          :author       => author)
+        return comment
+      end
+    end
   end 
 end

data/lib/youtube_g/version.rb

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

data/test/test_client.rb

@@ -149,7 +149,8 @@ class TestClient < Test::Unit::TestCase
   
   def test_should_get_videos_for_query_search_with_categories_excluded
     video = @client.video_by("EkF4JD2rO3Q")
-    assert_equal "<object width=\"425\" height=\"350\">\n  <param name=\"movie\" value=\"http://www.youtube.com/v/EkF4JD2rO3Q\"></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_equal "<object width=\"425\" height=\"350\">\n  <param name=\"movie\" value=\"http://www.youtube.com/v/EkF4JD2rO3Q&feature=youtube_gdata\"></param>\n  <param name=\"wmode\" value=\"transparent\"></param>\n  <embed src=\"http://www.youtube.com/v/EkF4JD2rO3Q\" type=\"application/x-shockwave-flash\" \n   wmode=\"transparent\" width=\"425\" height=\"350\"></embed>\n</object>\n", video.embed_html
+    assert_equal "<object width=\"425\" height=\"350\">\n  <param name=\"movie\" value=\"http://www.youtube.com/v/EkF4JD2rO3Q&feature=youtube_gdata\"></param>\n  <param name=\"wmode\" value=\"transparent\"></param>\n  <embed src=\"http://www.youtube.com/v/EkF4JD2rO3Q&feature=youtube_gdata\" type=\"application/x-shockwave-flash\" \n   wmode=\"transparent\" width=\"425\" height=\"350\"></embed>\n</object>\n", video.embed_html
     assert_valid_video video
   end
 

metadata

@@ -1,12 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: natedaiger-youtube-g
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 5
-  - 1
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors: 
 - Shane Vitarana
@@ -23,30 +18,24 @@ default_executable:
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: builder
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
         version: "0"
-  type: :runtime
-  version_requirements: *id001
+    version: 
 - !ruby/object:Gem::Dependency 
   name: hoe
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 8
-        - 3
         version: 1.8.3
-  type: :development
-  version_requirements: *id002
+    version: 
 description: "youtube-g is a pure Ruby client for the YouTube GData API. It provides an easy way to access the latest YouTube video search results from your own programs. In comparison with the earlier Youtube search interfaces, this new API and library offers much-improved flexibility around executing complex search queries to obtain well-targeted video search results.  More detail on the underlying source Google-provided API is available at:  http://code.google.com/apis/youtube/overview.html"
 email: shanev@gmail.com
 executables: []
@@ -104,20 +93,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
+  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
+  version: 
 requirements: []
 
 rubyforge_project: youtube-g
-rubygems_version: 1.3.6
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 2
 summary: Ruby client for the YouTube GData API