msp-youtube-g 0.4.5

data/lib/youtube_g/request/video_search.rb

@@ -0,0 +1,168 @@
+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, published, rating)
+      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)
+      attr_reader :racy                            # racy ([exclude], include)
+      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
+        # 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
+        @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,
+          'racy' => @racy,
+          '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
+        end
+        
+    end
+  end
+end

data/lib/youtube_g/request/video_upload.rb

@@ -0,0 +1,126 @@
+require 'net/https'
+require 'digest/md5'
+require 'rexml/document'
+require 'cgi'
+
+class YouTubeG
+
+  module Upload
+    class UploadError < Exception; end
+
+    # require 'youtube_g'
+    #
+    # uploader = YouTubeG::Upload::VideoUpload.new("user", "pass", "dev-key")
+    # uploader.upload File.open("test.m4v"), :title => 'test',
+    #                                        :description => 'cool vid d00d',
+    #                                        :category => 'People',
+    #                                        :keywords => %w[cool blah test]
+
+    class VideoUpload
+
+      def initialize user, pass, dev_key, client_id = 'youtube_g'
+        @user, @pass, @dev_key, @client_id = user, pass, dev_key, client_id
+      end
+
+      #
+      # Upload "data" to youtube, where data is either an IO object or
+      # raw file data.
+      # The hash keys for opts (which specify video info) are as follows:
+      #   :mime_type
+      #   :filename
+      #   :title
+      #   :description
+      #   :category
+      #   :keywords
+      #
+
+      def upload data, opts = {}
+        data = data.respond_to?(:read) ? data.read : data
+        @opts = { :mime_type => 'video/mp4',
+                  :filename => Digest::MD5.hexdigest(data),
+                  :title => '',
+                  :description => '',
+                  :category => '',
+                  :keywords => [] }.merge(opts)
+
+        upload_body = generate_upload_body(boundary, video_xml, data)
+
+        upload_header = {
+        "Authorization"  => "GoogleLogin auth=#{auth_token}",
+        "X-GData-Client" => "#{@client_id}",
+        "X-GData-Key"    => "key=#{@dev_key}",
+        "Slug"           => "#{@opts[:filename]}",
+        "Content-Type"   => "multipart/related; boundary=#{boundary}",
+        "Content-Length" => "#{upload_body.length}",
+        }
+        puts("MSP upload_header [#{upload_header}]")
+
+        direct_upload_url = "/feeds/api/users/#{@user}/uploads"
+        puts("MSP direct_upload_url [#{direct_upload_url}]")
+
+        Net::HTTP.start(base_url) do |upload|
+          response = upload.post(direct_upload_url, upload_body, upload_header)
+          xml = REXML::Document.new(response.body)
+          if (xml.elements["//id"])
+            puts("MSP response xml [#{xml}]")
+            return xml.elements["//id"].text[/videos\/(.+)/, 1]
+          else
+            return xml
+          end
+
+
+        end
+
+      end
+
+      private
+
+      def base_url
+        "uploads.gdata.youtube.com"
+      end
+
+      def boundary
+        "An43094fu"
+      end
+
+      def auth_token
+        unless @auth_token
+          http = Net::HTTP.new("www.google.com", 443)
+          http.use_ssl = true
+          body = "Email=#{CGI::escape @user}&Passwd=#{CGI::escape @pass}&service=youtube&source=#{CGI::escape @client_id}"
+          puts("MSP auth body [#{body}]")
+          response = http.post("/youtube/accounts/ClientLogin", body, "Content-Type" => "application/x-www-form-urlencoded")
+          raise UploadError, "MSP "+response.body[/Error=(.+)/,1] if response.code.to_i != 200
+          puts("MSP response.body [#{response.body}]")
+          @auth_token = response.body[/Auth=(.+)/, 1]
+
+        end
+        puts "MSP auth_token [#{@auth_token}]"
+        @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> ]
+      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
+
+    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/lib/youtube_g.rb

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

data/test/test_client.rb

@@ -0,0 +1,226 @@
+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?start-index=1&max-results=25&vq=penguin", 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
+  
+  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 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
+  
+  def test_should_handle_video_not_yet_viewed
+    response = @client.videos_by(:query => "YnqHZDh_t2Q")
+
+    assert_equal 1, response.videos.length
+    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/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
+  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
+
+    video = @client.video_by("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,30 @@
+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
+
+  def test_should_have_related_videos
+    video = YouTubeG::Model::Video.new(:video_id => "http://gdata.youtube.com/feeds/videos/BDqs-OZWw9o")
+    response = video.related
+
+    assert_equal "http://gdata.youtube.com/feeds/api/videos/BDqs-OZWw9o/related", response.feed_id
+    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
+end