msp-youtube-g 0.4.7 → 0.4.8.1

data/lib/youtube_g/parser.rb

@@ -1,15 +1,12 @@
-require 'cgi'
-require 'open-uri'
-require 'rexml/document'
-
 class YouTubeG
-  module Parser      
-    class FeedParserError < Exception; end
+  module Parser #:nodoc:      
+    class FeedParserError < Exception; end #:nodoc:
       
-    class FeedParser    
+    class FeedParser #:nodoc:   
       attr_reader :url_based
       alias :url_based? :url_based
-
+       
+      # Accept a URL or a string assumed to be XML.
       def initialize(arg)                    
         @url_based = assert_valid_url(arg)
         @content = arg
@@ -32,7 +29,7 @@ class YouTubeG
       end          
     end
      
-    class UploadErrorParser   
+    class UploadErrorParser #:nodoc:   
       def initialize(xml)
         raise YouTubeG::Parser::FeedParserError.new("You must pass some xml") if xml == ''
         @doc = REXML::Document.new(xml)         
@@ -51,24 +48,23 @@ class YouTubeG
         return upload_errors
       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)           
                               
         app_control_element = entry.elements["app:control"]     
-        app_contrlol = nil
+        app_control = nil
         if app_control_element
           app_control = YouTubeG::Model::Video::AppControl.new(
                      :draft => app_control_element.elements["app:draft"].text,
@@ -140,7 +136,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,
@@ -163,7 +159,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)
@@ -180,10 +176,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"]
 
@@ -209,4 +205,4 @@ class YouTubeG
     end
       
   end 
-end
+end

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/base_search.rb

@@ -0,0 +1,43 @@
+class YouTubeG
+  module Request #:nodoc: 
+    class BaseSearch #:nodoc:
+      attr_reader :url
+
+      private
+
+      def base_url #:nodoc:
+        "http://gdata.youtube.com/feeds/api/"                
+      end
+
+      def set_instance_variables( variables ) #:nodoc:
+        variables.each do |key, value| 
+          name = key.to_s
+          instance_variable_set("@#{name}", value) if respond_to?(name)
+        end
+      end
+
+      def build_query_params(params) #:nodoc:
+        # nothing to do if there are no params
+        return '' if (!params || params.empty?)
+
+        # build up the query param string, tacking on every key/value
+        # pair for which the value is non-nil
+        u = '?'
+        item_count = 0
+        params.keys.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/request/standard_search.rb

@@ -0,0 +1,40 @@
+class YouTubeG
+  module Request #:nodoc:  
+    class StandardSearch < BaseSearch #:nodoc:
+      attr_reader :max_results                     # max_results
+      attr_reader :order_by                        # orderby, ([relevance], viewCount, published, rating)
+      attr_reader :offset                          # start-index
+      attr_reader :time                            # time
+
+      TYPES = [ :top_rated, :top_favorites, :most_viewed, :most_popular,
+                :most_recent, :most_discussed, :most_linked, :most_responded,
+                :recently_featured, :watch_on_mobile ]
+
+      def initialize(type, options={})
+        if TYPES.include?(type)
+          @max_results, @order_by, @offset, @time = nil
+          set_instance_variables(options)
+          @url = base_url + type.to_s << build_query_params(to_youtube_params)
+        else
+          raise "Invalid type, must be one of: #{ TYPES.map { |t| t.to_s }.join(", ") }"
+        end
+      end
+
+      private
+
+      def base_url #:nodoc:
+        super << "standardfeeds/"        
+      end
+
+      def to_youtube_params #:nodoc:
+        { 
+          'max-results' => @max_results, 
+          'orderby' => @order_by, 
+          'start-index' => @offset, 
+          'time' => @time 
+        }
+      end   
+    end
+    
+  end
+end

data/lib/youtube_g/request/user_search.rb

@@ -0,0 +1,18 @@
+class YouTubeG
+  module Request #:nodoc:  
+    class UserSearch < BaseSearch #:nodoc:      
+      def initialize(params, options={})
+        @url = base_url
+        return @url << "#{options[:user]}/favorites" if params == :favorites
+        @url << "#{params[:user]}/uploads" if params[:user]
+      end
+
+      private
+
+      def base_url #:nodoc:
+        super << "users/"
+      end
+    end
+    
+  end
+end

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,8 +1,3 @@
-require 'net/https'
-require 'digest/md5'
-require 'rexml/document'
-require 'cgi'
-
 class YouTubeG
 
   module Upload
@@ -97,15 +92,15 @@ class YouTubeG
 
       private
 
-      def base_url
+      def base_url #:nodoc:
         "uploads.gdata.youtube.com"
       end
 
-      def boundary
+      def boundary #:nodoc:
         "An43094fu"
       end
 
-      def derive_auth_token     
+      def derive_auth_token #:nodoc:    
         unless @auth_token
           http = Net::HTTP.new("www.google.com", 443)
           http.use_ssl = true
@@ -121,7 +116,7 @@ class YouTubeG
         @auth_token
       end
 
-      def video_xml
+      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">'
@@ -135,17 +130,17 @@ class YouTubeG
         video_xml << '</entry>'
       end
 
-      def generate_upload_body(boundary, video_xml, data)
-        upload_body = ""
-        upload_body << "--#{boundary}\r\n"
-        upload_body << "Content-Type: application/atom+xml; charset=UTF-8\r\n\r\n"
-        upload_body << video_xml
-        upload_body << "\r\n--#{boundary}\r\n"
-        upload_body << "Content-Type: #{@opts[:mime_type]}\r\nContent-Transfer-Encoding: binary\r\n\r\n"
-        upload_body << data
-        upload_body << "\r\n--#{boundary}--\r\n"
-      end      
-     
+      def generate_upload_body(boundary, video_xml, data) #:nodoc:
+        uploadBody = ""
+        uploadBody << "--#{boundary}\r\n"
+        uploadBody << "Content-Type: application/atom+xml; charset=UTF-8\r\n\r\n"
+        uploadBody << video_xml
+        uploadBody << "\r\n--#{boundary}\r\n"
+        uploadBody << "Content-Type: #{@opts[:mime_type]}\r\nContent-Transfer-Encoding: binary\r\n\r\n"
+        uploadBody << data
+        uploadBody << "\r\n--#{boundary}--\r\n"
+      end
+
     end
   end
-end
+end