agiley-youtube-g 0.6.2

data/lib/youtube_g/record.rb

@@ -0,0 +1,12 @@
+class YouTubeG
+  class Record #:nodoc:
+    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/base_search.rb

@@ -0,0 +1,26 @@
+class YouTubeG
+  module Request #:nodoc: 
+    class BaseSearch #:nodoc:
+      attr_reader :url
+      
+      private
+      
+      def base_url
+        "http://gdata.youtube.com/feeds/api/"                
+      end
+      
+      def set_instance_variables( variables )
+        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)
+        qs = params.to_a.map { | k, v | v.nil? ? nil : "#{YouTubeG.esc(k)}=#{YouTubeG.esc(v)}" }.compact.sort.join('&')
+        qs.empty? ? '' : "?#{qs}"
+      end
+    end
+    
+  end
+end

data/lib/youtube_g/request/comments_search.rb

@@ -0,0 +1,41 @@
+class YouTubeG
+  module Request #:nodoc:  
+    class CommentsSearch < BaseSearch #:nodoc:      
+      attr_reader :max_results                     # max_results
+      attr_reader :offset                          # start-index
+
+      def initialize(video_id, options={})
+        @max_results, @order_by, @offset = nil
+        @url = base_url
+
+        @url << "videos/#{video_id}/comments"
+        set_instance_variables(options)
+
+        if options.has_key?(:per_page)
+          @max_results = options[:per_page]
+        end
+        
+        if options.has_key?(:page)
+          per_page = @max_results || 25
+          @offset = calculate_offset(options[:page], per_page)
+        end
+        
+        @url << build_query_params(to_youtube_params)
+      end
+
+      private
+
+      def to_youtube_params
+        {
+          'max-results' => @max_results,
+          'start-index' => @offset
+        }
+      end
+    private
+      def calculate_offset(page, per_page)
+        page == 1 ? 1 : ((per_page * page) - per_page + 1)
+      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
+        super << "standardfeeds/"        
+      end
+
+      def to_youtube_params
+        { 
+          '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,43 @@
+class YouTubeG
+  module Request #:nodoc:  
+    class UserSearch < BaseSearch #:nodoc:      
+      attr_reader :max_results                     # max_results
+      attr_reader :order_by                        # orderby, ([relevance], viewCount, published, rating)
+      attr_reader :offset                          # start-index
+
+      def initialize(params, options={})
+        @max_results, @order_by, @offset = nil
+        @url = base_url
+
+        if params == :favorites
+          @url << "#{options[:user]}/favorites" 
+          set_instance_variables(options)
+        elsif params[:user] && options[:favorites]
+          @url << "#{params[:user]}/favorites"
+          set_instance_variables(params)
+          return
+        elsif params[:user]
+          @url << "#{params[:user]}/uploads"
+          set_instance_variables(params)
+        end
+        
+        @url << build_query_params(to_youtube_params)
+      end
+
+      private
+
+      def base_url
+        super << "users/"
+      end
+
+      def to_youtube_params
+        {
+          'max-results' => @max_results,
+          'orderby' => @order_by,
+          'start-index' => @offset
+        }
+      end
+    end
+    
+  end
+end

data/lib/youtube_g/request/video_search.rb

@@ -0,0 +1,93 @@
+class YouTubeG
+  module Request #:nodoc:    
+    class VideoSearch < BaseSearch #:nodoc:
+      # 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={})
+        # Initialize our various member data to avoid warnings and so we'll
+        # automatically fall back to the youtube api defaults
+        @max_results, @order_by, 
+        @offset, @query, 
+        @response_format, @video_format, 
+        @racy, @author = nil
+        @url = base_url
+        
+        # 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]
+
+        set_instance_variables(params)
+        
+        if( params[ :only_embeddable ] )
+          @video_format = ONLY_EMBEDDABLE
+        end
+
+        @url << build_query_params(to_youtube_params)
+      end
+      
+      private
+      
+      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
+
+      # 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| YouTubeG.esc(t.to_s) }.join("%7C") << '/' if tags[:either]
+          s << tags[:include].map { |t| YouTubeG.esc(t.to_s) }.join("/") << '/' if tags[:include]            
+          s << ("-" << tags[:exclude].map { |t| YouTubeG.esc(t.to_s) }.join("/-")) << '/' if tags[:exclude]
+          s
+        else
+          tags.map { |t| YouTubeG.esc(t.to_s) }.join("/") << '/'
+        end          
+      end
+        
+    end
+  end
+end

data/lib/youtube_g/request/video_upload.rb

@@ -0,0 +1,218 @@
+class YouTubeG
+
+  module Upload
+    class UploadError < YouTubeG::Error; end
+    class AuthenticationError < YouTubeG::Error; end
+    
+    # Implements video uploads/updates/deletions
+    #
+    #   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
+      #   :private
+      # Specifying :private will make the video private, otherwise it will be public.
+      #
+      # When one of the fields is invalid according to YouTube,
+      # an UploadError will be raised. Its message contains a list of newline separated
+      # errors, containing the key and its error code.
+      # 
+      # When the authentication credentials are incorrect, an AuthenticationError will be raised.
+      def upload data, opts = {}
+        @opts = { :mime_type => 'video/mp4',
+                  :title => '',
+                  :description => '',
+                  :category => '',
+                  :keywords => [] }.merge(opts)
+        
+        @opts[:filename] ||= generate_uniq_filename_from(data)
+        
+        post_body_io = generate_upload_io(video_xml, data)
+        
+        upload_headers = authorization_headers.merge({
+            "Slug"           => "#{@opts[:filename]}",
+            "Content-Type"   => "multipart/related; boundary=#{boundary}",
+            "Content-Length" => "#{post_body_io.expected_length}", # required per YouTube spec
+          # "Transfer-Encoding" => "chunked" # We will stream instead of posting at once
+        })
+        
+        path = '/feeds/api/users/%s/uploads' % @user
+        
+        Net::HTTP.start(uploads_url) do | session |
+          
+          # Use the chained IO as body so that Net::HTTP reads into the socket for us
+          post = Net::HTTP::Post.new(path, upload_headers)
+          post.body_stream = post_body_io
+          
+          response = session.request(post)
+          raise_on_faulty_response(response)
+          
+          return uploaded_video_id_from(response.body)
+        end
+      end
+      
+      # Updates a video in YouTube.  Requires:
+      #   :title
+      #   :description
+      #   :category
+      #   :keywords
+      # The following are optional attributes:
+      #   :private
+      # When the authentication credentials are incorrect, an AuthenticationError will be raised.
+      def update(video_id, options)
+        @opts = options
+        
+        update_body = video_xml
+        
+        update_header = authorization_headers.merge({
+          "Content-Type"   => "application/atom+xml",
+          "Content-Length" => "#{update_body.length}",
+        })
+        
+        update_url = "/feeds/api/users/#{@user}/uploads/#{video_id}"
+        
+        Net::HTTP.start(base_url) do | session |
+          response = session.put(update_url, update_body, update_header)
+          raise_on_faulty_response(response)
+          
+          return YouTubeG::Parser::VideoFeedParser.new(response.body).parse
+        end
+      end
+      
+      # Delete a video on YouTube
+      def delete(video_id)
+        delete_header = authorization_headers.merge({
+          "Content-Type"   => "application/atom+xml",
+          "Content-Length" => "0",
+        })
+        
+        delete_url = "/feeds/api/users/#{@user}/uploads/#{video_id}"
+        
+        Net::HTTP.start(base_url) do |session|
+          response = session.delete(delete_url, delete_header)
+          raise_on_faulty_response(response)
+          return true
+        end
+      end
+      
+      private
+      
+      def uploads_url
+        ["uploads", base_url].join('.')
+      end
+      
+      def base_url
+        "gdata.youtube.com"
+      end
+      
+      def boundary 
+        "An43094fu"
+      end
+      
+      def authorization_headers
+        {
+          "Authorization"  => "GoogleLogin auth=#{auth_token}",
+          "X-GData-Client" => "#{@client_id}",
+          "X-GData-Key"    => "key=#{@dev_key}"
+        }
+      end
+      
+      def parse_upload_error_from(string)
+        REXML::Document.new(string).elements["//errors"].inject('') do | all_faults, error|
+          location = error.elements["location"].text[/media:group\/media:(.*)\/text\(\)/,1]
+          code = error.elements["code"].text
+          all_faults + sprintf("%s: %s\n", location, code)
+        end
+      end
+      
+      def raise_on_faulty_response(response)
+        if response.code.to_i == 403
+          raise AuthenticationError, response.body[/<TITLE>(.+)<\/TITLE>/, 1]
+        elsif response.code.to_i / 10 != 20 # Response in 20x means success
+          raise UploadError, parse_upload_error_from(response.body)
+        end 
+      end
+      
+      def uploaded_video_id_from(string)
+        xml = REXML::Document.new(string)
+        xml.elements["//id"].text[/videos\/(.+)/, 1]
+      end
+      
+      # If data can be read, use the first 1024 bytes as filename. If data
+      # is a file, use path. If data is a string, checksum it
+      def generate_uniq_filename_from(data)
+        if data.respond_to?(:path)
+          Digest::MD5.hexdigest(data.path)
+        elsif data.respond_to?(:read)
+          chunk = data.read(1024)
+          data.rewind
+          Digest::MD5.hexdigest(chunk)
+        else
+          Digest::MD5.hexdigest(data)
+        end
+      end
+      
+      def auth_token
+        @auth_token ||= begin
+          http = Net::HTTP.new("www.google.com", 443)
+          http.use_ssl = true
+          body = "Email=#{YouTubeG.esc @user}&Passwd=#{YouTubeG.esc @pass}&service=youtube&source=#{YouTubeG.esc @client_id}"
+          response = http.post("/youtube/accounts/ClientLogin", body, "Content-Type" => "application/x-www-form-urlencoded")
+          raise UploadError, response.body[/Error=(.+)/,1] if response.code.to_i != 200
+          @auth_token = response.body[/Auth=(.+)/, 1]
+        end
+      end
+      
+      # TODO: isn't there a cleaner way to output top-notch XML without requiring stuff all over the place?
+      def video_xml
+        b = Builder::XmlMarkup.new
+        b.instruct!
+        b.entry(:xmlns => "http://www.w3.org/2005/Atom", 'xmlns:media' => "http://search.yahoo.com/mrss/", 'xmlns:yt' => "http://gdata.youtube.com/schemas/2007") do | m |
+          m.tag!("media:group") do | mg |
+            mg.tag!("media:title", @opts[:title], :type => "plain")
+            mg.tag!("media:description", @opts[:description], :type => "plain")
+            mg.tag!("media:keywords", @opts[:keywords].join(","))
+            mg.tag!('media:category', @opts[:category], :scheme => "http://gdata.youtube.com/schemas/2007/categories.cat")
+            mg.tag!('yt:private') if @opts[:private]
+          end
+        end.to_s
+      end
+      
+      def generate_upload_io(video_xml, data)
+        post_body = [
+          "--#{boundary}\r\n",
+          "Content-Type: application/atom+xml; charset=UTF-8\r\n\r\n",
+          video_xml,
+          "\r\n--#{boundary}\r\n",
+          "Content-Type: #{@opts[:mime_type]}\r\nContent-Transfer-Encoding: binary\r\n\r\n",
+          data,
+          "\r\n--#{boundary}--\r\n",
+        ]
+        
+        # Use Greedy IO to not be limited by 1K chunks
+        YouTubeG::GreedyChainIO.new(post_body)
+      end
+
+    end
+  end
+end