vibedeck-youtube_it 0.0.1

data/lib/youtube_it/client.rb

@@ -0,0 +1,367 @@
+class YouTubeIt
+  class Client
+    include YouTubeIt::Logging
+    # Previously this was a logger instance but we now do it globally
+
+    def initialize *params
+      if params.first.is_a?(Hash)
+        hash_options = params.first
+        @user                  = hash_options[:username]
+        @pass                  = hash_options[:password]
+        @dev_key               = hash_options[:dev_key]
+        @client_id             = hash_options[:client_id] || "youtube_it"
+        @legacy_debug_flag     = hash_options[:debug]
+      elsif params.first
+        puts "* warning: the method YouTubeIt::Client.new(user, passwd, dev_key) is deprecated, use YouTubeIt::Client.new(:username => 'user', :password => 'passwd', :dev_key => 'dev_key')"
+        @user               = params.shift
+        @pass               = params.shift
+        @dev_key            = params.shift
+        @client_id          = params.shift || "youtube_it"
+        @legacy_debug_flag  = params.shift
+      end
+    end
+
+    # Retrieves an array of standard feed, custom query, or user videos.
+    #
+    # === Parameters
+    # If fetching videos for a standard feed:
+    #   params<Symbol>:: Accepts a symbol of :top_rated, :top_favorites, :most_viewed,
+    #                    :most_popular, :most_recent, :most_discussed, :most_linked,
+    #                    :most_responded, :recently_featured, and :watch_on_mobile.
+    #
+    #   You can find out more specific information about what each standard feed provides
+    #   by visiting: http://code.google.com/apis/youtube/reference.html#Standard_feeds
+    #
+    #   options<Hash> (optional)::  Accepts the options of :time, :page (default is 1),
+    #                               and :per_page (default is 25). :offset and :max_results
+    #                               can also be passed for a custom offset.
+    #
+    # If fetching videos by tags, categories, query:
+    #   params<Hash>:: Accepts the keys :tags, :categories, :query, :order_by,
+    #                  :author, :racy, :response_format, :video_format, :page (default is 1),
+    #                  and :per_page(default is 25)
+    #
+    #   options<Hash>:: Not used. (Optional)
+    #
+    # If fetching videos for a particular user:
+    #   params<Hash>:: Key of :user with a value of the username.
+    #   options<Hash>:: Not used. (Optional)
+    # === Returns
+    # YouTubeIt::Response::VideoSearch
+    def videos_by(params, options={})
+      request_params = params.respond_to?(:to_hash) ? params : options
+      request_params[:page] = integer_or_default(request_params[:page], 1)
+
+      request_params[:dev_key] = @dev_key if @dev_key
+
+      unless request_params[:max_results]
+        request_params[:max_results] = integer_or_default(request_params[:per_page], 25)
+      end
+
+      unless request_params[:offset]
+        request_params[:offset] = calculate_offset(request_params[:page], request_params[:max_results] )
+      end
+
+      if params.respond_to?(:to_hash) and not params[:user]
+        request = YouTubeIt::Request::VideoSearch.new(request_params)
+      elsif (params.respond_to?(:to_hash) && params[:user]) || (params == :favorites)
+        request = YouTubeIt::Request::UserSearch.new(params, request_params)
+      else
+        request = YouTubeIt::Request::StandardSearch.new(params, request_params)
+      end
+
+      logger.debug "Submitting request [url=#{request.url}]." if @legacy_debug_flag
+      parser = YouTubeIt::Parser::VideosFeedParser.new(request.url)
+      parser.parse
+    end
+
+    # Retrieves a single YouTube video.
+    #
+    # === Parameters
+    #   vid<String>:: The ID or URL of the video that you'd like to retrieve.
+    #   user<String>:: The user that uploaded the video that you'd like to retrieve.
+    #
+    # === Returns
+    # YouTubeIt::Model::Video
+    def video_by(vid)
+      video_id = vid =~ /^http/ ? vid : "http://gdata.youtube.com/feeds/api/videos/#{vid}?v=2#{@dev_key ? '&key='+@dev_key : ''}"
+      parser = YouTubeIt::Parser::VideoFeedParser.new(video_id)
+      parser.parse
+    end
+
+    def video_by_user(user, vid)
+      video_id = "http://gdata.youtube.com/feeds/api/users/#{user}/uploads/#{vid}?v=2#{@dev_key ? '&key='+@dev_key : ''}"
+      parser = YouTubeIt::Parser::VideoFeedParser.new(video_id)
+      parser.parse
+    end
+
+    def video_upload(data, opts = {})
+      client.upload(data, opts)
+    end
+
+    def video_update(video_id, opts = {})
+      client.update(video_id, opts)
+    end
+
+    def video_delete(video_id)
+      client.delete(video_id)
+    end
+
+    def upload_token(options, nexturl = "http://www.youtube.com/my_videos")
+      client.get_upload_token(options, nexturl)
+    end
+
+    def add_comment(video_id, comment)
+      client.add_comment(video_id, comment)
+    end
+
+    # opts is converted to get params and appended to comments gdata api url
+    # eg opts = { 'max-results' => 10, 'start-index' => 20 }
+    # hash does _not_ play nice with symbols
+    def comments(video_id, opts = {})
+      client.comments(video_id, opts)
+    end
+
+    def add_favorite(video_id)
+      client.add_favorite(video_id)
+    end
+
+    def delete_favorite(video_id)
+      client.delete_favorite(video_id)
+    end
+
+    def favorites(user = nil, opts = {})
+      client.favorites(user, opts)
+    end
+
+    def profile(user = nil)
+      client.profile(user)
+    end
+
+    def playlist(playlist_id)
+      client.playlist playlist_id
+    end
+
+    def playlists(user = nil)
+      client.playlists(user)
+    end
+
+    def add_playlist(options)
+      client.add_playlist(options)
+    end
+
+    def update_playlist(playlist_id, options)
+      client.update_playlist(playlist_id, options)
+    end
+
+    def add_video_to_playlist(playlist_id, video_id)
+      client.add_video_to_playlist(playlist_id, video_id)
+    end
+
+    def delete_video_from_playlist(playlist_id, playlist_entry_id)
+      client.delete_video_from_playlist(playlist_id, playlist_entry_id)
+    end
+
+    def delete_playlist(playlist_id)
+      client.delete_playlist(playlist_id)
+    end
+
+    def like_video(video_id)
+      client.rate_video(video_id, 'like')
+    end
+
+    def dislike_video(video_id)
+      client.rate_video(video_id, 'dislike')
+    end
+    
+    def subscribe_channel(channel_name)
+      client.subscribe_channel(channel_name)
+    end
+
+    def unsubscribe_channel(subscription_id)
+      client.unsubscribe_channel(subscription_id)
+    end
+    
+    def subscriptions(user_id = nil)
+      client.subscriptions(user_id)
+    end
+
+    def enable_http_debugging
+      client.enable_http_debugging
+    end
+
+    def current_user
+      client.get_current_user
+    end
+    
+    # Gets the authenticated users video with the given ID. It may be private.
+    def my_video(video_id)
+      client.get_my_video(video_id)
+    end
+
+    # Gets all videos 
+    def my_videos(opts = {})
+      client.get_my_videos(opts)
+    end
+
+    private
+
+    def client
+      @client ||= YouTubeIt::Upload::VideoUpload.new(:username => @user, :password => @pass, :dev_key => @dev_key)
+    end
+
+    def calculate_offset(page, per_page)
+      page == 1 ? 1 : ((per_page * page) - per_page + 1)
+    end
+
+    def integer_or_default(value, default)
+      value = value.to_i
+      value > 0 ? value : default
+    end
+  end
+
+  class AuthSubClient < Client
+    def initialize *params
+      if params.first.is_a?(Hash)
+        hash_options = params.first
+        @authsub_token                 = hash_options[:token]
+        @dev_key                       = hash_options[:dev_key]
+        @client_id                     = hash_options[:client_id] || "youtube_it"
+        @legacy_debug_flag             = hash_options[:debug]
+      else
+        puts "* warning: the method YouTubeIt::AuthSubClient.new(token, dev_key) is depricated, use YouTubeIt::AuthSubClient.new(:token => 'token', :dev_key => 'dev_key')"
+        @authsub_token              = params.shift
+        @dev_key                    = params.shift
+        @client_id                  = params.shift || "youtube_it"
+        @legacy_debug_flag          = params.shift
+      end
+    end
+
+    def create_session_token
+      response = nil
+      session_token_url = "/accounts/AuthSubSessionToken"
+
+      http_connection do |session|
+        response = session.get2('https://%s' % session_token_url,session_token_header).body
+      end
+      @authsub_token = response.sub('Token=','')
+    end
+
+    def revoke_session_token
+      response = nil
+      session_token_url = "/accounts/AuthSubRevokeToken"
+
+      http_connection do |session|
+        response = session.get2('https://%s' % session_token_url,session_token_header).code
+      end
+      response.to_s == '200' ? true : false
+    end
+
+    def session_token_info
+      response = nil
+      session_token_url = "/accounts/AuthSubTokenInfo"
+
+      http_connection do |session|
+        response = session.get2('https://%s' % session_token_url,session_token_header)
+      end
+      {:code => response.code, :body => response.body }
+    end
+
+    private
+      def client
+        @client ||= YouTubeIt::Upload::VideoUpload.new(:dev_key => @dev_key, :authsub_token => @authsub_token)
+      end
+
+      def session_token_header
+        {
+          "Content-Type"   => "application/x-www-form-urlencoded",
+          "Authorization"  => "AuthSub token=#{@authsub_token}"
+        }
+      end
+
+      def http_connection
+        http = Net::HTTP.new("www.google.com")
+        http.set_debug_output(logger) if @http_debugging
+        http.start do |session|
+          yield(session)
+        end
+      end
+  end
+
+  class OAuthClient < Client
+    def initialize *params
+      if params.first.is_a?(Hash)
+        hash_options = params.first
+        @consumer_key                  = hash_options[:consumer_key]
+        @consumer_secret               = hash_options[:consumer_secret]
+        @user                          = hash_options[:username]
+        @dev_key                       = hash_options[:dev_key]
+        @client_id                     = hash_options[:client_id] || "youtube_it"
+        @legacy_debug_flag             = hash_options[:debug]
+      else
+        puts "* warning: the method YouTubeIt::OAuthClient.new(consumer_key, consumer_secrect, dev_key) is depricated, use YouTubeIt::OAuthClient.new(:consumer_key => 'consumer key', :consumer_secret => 'consumer secret', :dev_key => 'dev_key')"
+        @consumer_key                  = params.shift
+        @consumer_secret               = params.shift
+        @dev_key                       = params.shift
+        @user                          = params.shift
+        @client_id                     = params.shift || "youtube_it"
+        @legacy_debug_flag             = params.shift
+      end
+    end
+
+    def consumer
+      @consumer ||= ::OAuth::Consumer.new(@consumer_key,@consumer_secret,{
+        :site=>"https://www.google.com",
+        :request_token_path=>"/accounts/OAuthGetRequestToken",
+        :authorize_path=>"/accounts/OAuthAuthorizeToken",
+        :access_token_path=>"/accounts/OAuthGetAccessToken"})
+    end
+
+    def request_token(callback)
+      @request_token = consumer.get_request_token({:oauth_callback => callback},{:scope => "http://gdata.youtube.com"})
+    end
+
+    def access_token
+      @access_token = ::OAuth::AccessToken.new(consumer, @atoken, @asecret)
+    end
+
+    def config_token
+      {
+        :consumer_key => @consumer_key,
+        :consumer_secret => @consumer_secret,
+        :token => @atoken,
+        :token_secret => @asecret
+       }
+    end
+
+    def authorize_from_request(rtoken,rsecret,verifier)
+      request_token = ::OAuth::RequestToken.new(consumer,rtoken,rsecret)
+      access_token = request_token.get_access_token({:oauth_verifier => verifier})
+      @atoken,@asecret = access_token.token, access_token.secret
+    end
+
+    def authorize_from_access(atoken,asecret)
+      @atoken,@asecret = atoken, asecret
+    end
+
+    def current_user
+      yt_session = Faraday.new(:url => "http://gdata.youtube.com") do |builder|
+        builder.use Faraday::Response::YouTubeIt 
+        builder.use Faraday::Request::OAuth, config_token
+        builder.adapter Faraday.default_adapter          
+      end
+      
+      body = yt_session.get("/feeds/api/users/default").body
+      REXML::Document.new(body).elements["entry"].elements['author'].elements['name'].text
+    end
+
+    private
+
+    def client
+      # IMPORTANT: make sure authorize_from_access is called before client is fetched
+      @client ||= YouTubeIt::Upload::VideoUpload.new(:username => current_user, :dev_key => @dev_key, :access_token => access_token, :config_token => config_token)
+    end
+
+  end
+end
+

data/lib/youtube_it/middleware/faraday_authheader.rb

@@ -0,0 +1,24 @@
+module Faraday
+  class Request::AuthHeader < Faraday::Middleware
+
+    def call(env)
+      req_headers = env[:request_headers]
+      req_headers.merge!(@headers)
+      unless req_headers.include?("GData-Version")
+        req_headers.merge!("GData-Version" => "2")
+      end
+      unless req_headers.include?("Content-Type")
+        req_headers.merge!("Content-Type"  => "application/atom+xml; charset=UTF-8")
+      end
+      unless req_headers.include?("Content-Length")
+        req_headers.merge!("Content-Length"  => env[:body] ? "#{env[:body].length}" : "0")
+      end
+
+      @app.call(env)
+    end
+
+    def initialize(app, headers)
+      @app, @headers = app, headers
+    end
+  end
+end

data/lib/youtube_it/middleware/faraday_oauth.rb

@@ -0,0 +1,21 @@
+module Faraday
+  class Request::OAuth < Faraday::Middleware
+    dependency 'simple_oauth'
+
+    def call(env)
+      params = env[:body].is_a?(Hash) ? env[:body] : {}
+
+      signature_params = params.reject{ |k,v| v.respond_to?(:content_type) }
+
+      header = SimpleOAuth::Header.new(env[:method], env[:url], signature_params, @options)
+
+      env[:request_headers]['Authorization'] = header.to_s
+
+      @app.call(env)
+    end
+
+    def initialize(app, options)
+      @app, @options = app, options
+    end
+  end
+end

data/lib/youtube_it/middleware/faraday_youtubeit.rb

@@ -0,0 +1,30 @@
+module Faraday
+  class Response::YouTubeIt < Response::Middleware
+    def parse_upload_error_from(string)
+      begin
+        REXML::Document.new(string).elements["//errors"].inject('') do | all_faults, error|
+          if error.elements["internalReason"]
+            msg_error = error.elements["internalReason"].text
+          elsif error.elements["location"]
+            msg_error = error.elements["location"].text[/media:group\/media:(.*)\/text\(\)/,1]
+          else
+            msg_error = "Unspecified error"
+          end
+          code = error.elements["code"].text if error.elements["code"]
+          all_faults + sprintf("%s: %s\n", msg_error, code)
+        end
+      rescue
+        string[/<TITLE>(.+)<\/TITLE>/, 1] || string
+      end
+    end
+
+    def on_complete(env) #this method is called after finish request
+      msg = parse_upload_error_from(env[:body].gsub(/\n/, ''))
+      if env[:status] == 403 || env[:status] == 401
+        raise ::AuthenticationError.new(msg, env[:status])
+      elsif env[:status] / 10 != 20
+        raise ::UploadError.new(msg, env[:status])
+      end
+    end
+  end
+end

data/lib/youtube_it/model/author.rb

@@ -0,0 +1,13 @@
+class YouTubeIt
+  module Model
+    class Author < YouTubeIt::Record
+      # *String*: Author's YouTube username.
+      attr_reader :name
+      
+      # *String*: Feed URL of the author.
+      attr_reader :uri
+      
+      attr_reader :thumbnail_url
+    end
+  end
+end

data/lib/youtube_it/model/category.rb

@@ -0,0 +1,11 @@
+class YouTubeIt
+  module Model
+    class Category < YouTubeIt::Record
+      # *String*:: Name of the YouTube category
+      attr_reader :label 
+      
+      # *String*:: Identifies the type of item described.
+      attr_reader :term
+    end
+  end
+end

data/lib/youtube_it/model/comment.rb

@@ -0,0 +1,16 @@
+class YouTubeIt
+  module Model
+    class Comment < YouTubeIt::Record
+      attr_reader :content, :published, :title, :updated, :url
+
+      # YouTubeIt::Model::Author:: Information about the YouTube user who owns a piece of video content.
+      attr_reader :author
+      
+      # unique ID of the comment.
+      def unique_id
+        url.split("/").last
+      end
+    end
+  end
+end
+

data/lib/youtube_it/model/contact.rb

@@ -0,0 +1,16 @@
+class YouTubeIt
+  module Model
+    class Contact < YouTubeIt::Record
+      # *String*:: Identifies the status of a contact.
+      #
+      # * The tag's value will be accepted if the authenticated user and the contact have marked each other as friends.
+      # * The tag's value will be requested if the contact has asked to be added to the authenticated user's contact list, but the request has not yet been accepted (or rejected).
+      # * The tag's value will be pending if the authenticated user has asked to be added to the contact's contact list, but the request has not yet been accepted or rejected.
+      #
+      attr_reader :status
+      
+      # *String*:: The Youtube username of the contact.
+      attr_reader :username
+    end
+  end
+end

data/lib/youtube_it/model/content.rb

@@ -0,0 +1,18 @@
+class YouTubeIt
+  module Model
+    class Content < YouTubeIt::Record
+      # *Boolean*:: Description of the video.
+      attr_reader :default
+      # *Fixnum*:: Length of the video in seconds.
+      attr_reader :duration
+      # YouTubeIt::Model::Video::Format:: Specifies the video format of the video object
+      attr_reader :format
+      # *String*:: Specifies the MIME type of the media object.
+      attr_reader :mime_type
+      # *String*:: Specifies the URL for the media object.
+      attr_reader :url
+      
+      alias :is_default? :default
+    end
+  end
+end

data/lib/youtube_it/model/playlist.rb

@@ -0,0 +1,11 @@
+class YouTubeIt
+  module Model
+    class Playlist < YouTubeIt::Record
+      attr_reader :title, :description, :summary, :playlist_id, :xml, :published, :response_code
+      def videos
+        YouTubeIt::Parser::VideosFeedParser.new("http://gdata.youtube.com/feeds/api/playlists/#{playlist_id}?v=2").parse_videos
+      end
+    end
+  end
+end
+

data/lib/youtube_it/model/rating.rb

@@ -0,0 +1,23 @@
+class YouTubeIt
+  module Model
+    class Rating < YouTubeIt::Record
+      # *Float*:: Average rating given to the video
+      attr_reader :average
+      
+      # *Fixnum*:: Maximum rating that can be assigned to the video
+      attr_reader :max
+      
+      # *Fixnum*:: Minimum rating that can be assigned to the video
+      attr_reader :min
+      
+      # *Fixnum*:: Indicates how many people have rated the video
+      attr_reader :rater_count
+
+      # *Fixnum*:: Indicates how many people likes this video
+      attr_reader :likes
+
+      # *Fixnum*:: Indicates how many people dislikes this video
+      attr_reader :dislikes
+    end
+  end
+end

data/lib/youtube_it/model/subscription.rb

@@ -0,0 +1,7 @@
+class YouTubeIt
+  module Model
+    class Subscription < YouTubeIt::Record
+      attr_reader :id, :title, :published
+    end
+  end
+end

data/lib/youtube_it/model/thumbnail.rb

@@ -0,0 +1,17 @@
+class YouTubeIt
+  module Model
+    class Thumbnail < YouTubeIt::Record
+      # *String*:: URL for the thumbnail image.
+      attr_reader :url
+      
+      # *Fixnum*:: Height of the thumbnail image.
+      attr_reader :height
+      
+      # *Fixnum*:: Width of the thumbnail image.
+      attr_reader :width
+      
+      # *String*:: Specifies the time offset at which the frame shown in the thumbnail image appears in the video.
+      attr_reader :time
+    end
+  end
+end

data/lib/youtube_it/model/user.rb

@@ -0,0 +1,26 @@
+class YouTubeIt
+  module Model
+    class User < YouTubeIt::Record
+      attr_reader :age
+      attr_reader :books
+      attr_reader :company
+      attr_reader :description
+      attr_reader :gender
+      attr_reader :hobbies
+      attr_reader :hometown
+      attr_reader :last_login
+      attr_reader :location
+      attr_reader :join_date
+      attr_reader :movies
+      attr_reader :music
+      attr_reader :occupation
+      attr_reader :relationship
+      attr_reader :school
+      attr_reader :subscribers
+      attr_reader :upload_views
+      attr_reader :username
+      attr_reader :videos_watched
+      attr_reader :view_count
+    end
+  end
+end