youtube_it 1.4.3 → 2.0.0

data/Manifest.txt

@@ -18,11 +18,15 @@ lib/youtube_it/model/video.rb
 lib/youtube_it/parser.rb
 lib/youtube_it/record.rb
 lib/youtube_it/request/base_search.rb
+lib/youtube_it/request/error.rb
 lib/youtube_it/request/standard_search.rb
 lib/youtube_it/request/user_search.rb
 lib/youtube_it/request/video_search.rb
 lib/youtube_it/request/video_upload.rb
 lib/youtube_it/response/video_search.rb
+lib/youtube_it/middleware/faraday_authheader.rb
+lib/youtube_it/middleware/faraday_oauth.rb
+lib/youtube_it/middleware/faraday_youtubeit.rb
 lib/youtube_it/version.rb
 test/helper.rb
 test/test_chain_io.rb

data/README.rdoc

@@ -13,6 +13,8 @@
   * Create a developer key here http://code.google.com/apis/youtube/dashboard.
   * sudo gem install youtube_it
 
+Note: youtube_it supports ClientLogin(YouTube account), OAuth or AuthSub authentication methods.
+
 == ESTABLISHING A CLIENT
 
 Creating a client:
@@ -52,9 +54,20 @@ Standard Queries:
 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'] })
 
+
+Fields Parameter(experimental features):
+  Return videos more than 1000 views
+  $ client.videos_by(:fields => {:view_count => "1000"})
+  Filter by date
+  $ client.videos_by(:fields => {:published  => ((Date.today)})
+  $ client.videos_by(:fields => {:recorded   => ((Date.today)})  
+  Filter by date with range
+  $ client.videos_by(:fields => {:published  => ((Date.today - 30)..(Date.today))})
+  $ client.videos_by(:fields => {:recorded   => ((Date.today - 30)..(Date.today))})  
+  
 == VIDEO MANAGEMENT
 
-Note: YouTube account or OAuth enables video management.
+Note: YouTube account, OAuth or AuthSub enables video management.
 
 Upload Video:
   $ client.video_upload(File.open("test.mov"), :title => "test",:description => 'some description', :category => 'People',:keywords => %w[cool blah test])
@@ -68,6 +81,12 @@ Update Video:
 Delete Video:
   $ client.video_delete("FQK1URcxmb4")
 
+My Videos:
+  $ client.my_videos
+
+My Video:
+  $ client.my_video(video_id)
+  
 Profile Details:
   $ client.profile(user_id)
 
@@ -78,7 +97,7 @@ Add A Comment:
   $ client.add_comment(video_id, "test comment!")
 
 List Favorites:
-  $ client.favorites
+  $ client.favorites(user) # current user by default
 
 Add Favorite:
   $ client.add_favorite(video_id)
@@ -86,8 +105,23 @@ Add Favorite:
 Delete Favorite:
   $ client.delete_favorite(video_id)
 
+Like A Video:
+  $ client.like_video(video_id)
+
+Dislike A Video:
+  $ client.dislike_video(video_id)
+
+List Subscriptions:
+  $ client.subscriptions(user) #default: current user
+
+Subscribe To A Channel:
+  $ client.subscribe_channel(channel_name)
+
+Unsubscribe To A Channel:
+  $ client.unsubscribe_channel(subscription_id)
+
 List Playlists:
-  $ client.playlists
+  $ client.playlists(user) # current user by default
 
 Select Playlist:
   $ client.playlist(playlist_id)
@@ -107,9 +141,6 @@ Add Video To Playlist:
 
 Remove Video From Playlist:
   $ client.remove_video_from_playlist(playlist_id, playlist_entry_id)
-
-Select Playlists From User:
-  $ client.playlists_for(user)
   
 == ACCESS CONTROL LIST
 

data/Rakefile

@@ -10,6 +10,8 @@ begin
     gem.email = "kylejginavan@gmail.com"
     gem.homepage = "http://github.com/kylejginavan/youtube_it"
     gem.add_dependency('oauth','>=0.4.4')
+    gem.add_dependency('simple_oauth', '>=0.1.5')    
+    gem.add_dependency('faraday','>=0.7.3')    
     gem.add_dependency('builder')
     gem.authors = ["kylejginavan","chebyte", "mseppae"]
   end
@@ -38,8 +40,6 @@ rescue LoadError
   end
 end
 
-task :test => :check_dependencies
-
 task :default => :test
 
 require 'rake/rdoctask'

data/VERSION

@@ -1 +1 @@
-1.4.3
+2.0.0

data/lib/youtube_it.rb

@@ -5,6 +5,7 @@ require 'digest/md5'
 require 'rexml/document'
 require 'builder'
 require 'oauth'
+require 'faraday'
 
 class YouTubeIt
   
@@ -56,14 +57,19 @@ end
   model/content
   model/playlist
   model/rating
+  model/subscription
   model/thumbnail
   model/user
   model/video
   request/base_search
+  request/error
   request/user_search
   request/standard_search
   request/video_upload
   request/video_search
   response/video_search
+  middleware/faraday_authheader.rb  
+  middleware/faraday_oauth.rb  
+  middleware/faraday_youtubeit.rb
   chain_io
 ).each{|m| require File.dirname(__FILE__) + '/youtube_it/' + m }

data/lib/youtube_it/client.rb

@@ -11,7 +11,7 @@ class YouTubeIt
         @dev_key               = hash_options[:dev_key]
         @client_id             = hash_options[:client_id] || "youtube_it"
         @legacy_debug_flag     = hash_options[:debug]
-      else
+      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
@@ -130,24 +130,20 @@ class YouTubeIt
       client.delete_favorite(video_id)
     end
 
-    def favorites(opts = {})
-      client.favorites(opts)
+    def favorites(user = nil, opts = {})
+      client.favorites(user, opts)
     end
 
-    def profile(user_id)
-      client.profile(user_id)
+    def profile(user = nil)
+      client.profile(user)
     end
 
     def playlist(playlist_id)
       client.playlist playlist_id
     end
 
-    def playlists
-      client.playlists
-    end
-
-    def playlists_for(user)
-     client.playlists_for(user)
+    def playlists(user = nil)
+      client.playlists(user)
     end
 
     def add_playlist(options)
@@ -170,6 +166,26 @@ class YouTubeIt
       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
@@ -177,6 +193,16 @@ class YouTubeIt
     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
 
@@ -299,6 +325,15 @@ class YouTubeIt
       @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})
@@ -318,7 +353,7 @@ class YouTubeIt
 
     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)
+      @client ||= YouTubeIt::Upload::VideoUpload.new(:username => current_user, :dev_key => @dev_key, :access_token => access_token, :config_token => config_token)
     end
 
   end

data/lib/youtube_it/middleware/faraday_authheader.rb

@@ -0,0 +1,13 @@
+module Faraday
+  class Request::AuthHeader < Faraday::Middleware
+
+    def call(env)
+      env[:request_headers].merge!(@headers)
+      @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/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/video.rb

@@ -114,6 +114,9 @@ class YouTubeIt
 
       # *Fixnum*:: Number of times that the video has been favorited
       attr_reader :favorite_count
+      
+      # *String*:: State of the video (processing, restricted, deleted, rejected and failed)
+      attr_reader :state
 
 
       # Geodata

data/lib/youtube_it/parser.rb

@@ -36,15 +36,15 @@ class YouTubeIt
         def parse_entry(entry)
           author = YouTubeIt::Model::Author.new(
             :name => entry.elements["author"].elements["name"].text,
-            :uri => entry.elements["author"].elements["uri"].text
+            :uri  => entry.elements["author"].elements["uri"].text
           )
           YouTubeIt::Model::Comment.new(
-            :author => author,
-            :content => entry.elements["content"].text,
+            :author    => author,
+            :content   => entry.elements["content"].text,
             :published => entry.elements["published"].text,
-            :title => entry.elements["title"].text,
-            :updated => entry.elements["updated "].text,
-            :url => entry.elements["id"].text
+            :title     => entry.elements["title"].text,
+            :updated   => entry.elements["updated "].text,
+            :url       => entry.elements["id"].text
           )
         end
     end
@@ -60,7 +60,7 @@ class YouTubeIt
           :description   => (entry.elements["summary"] || entry.elements["media:group"].elements["media:description"]).text,
           :playlist_id   => entry.elements["id"].text[/playlist([^<]+)/, 1].sub(':',''),
           :published     => entry.elements["published"] ? entry.elements["published"].text : nil,
-          :response_code => content.code,
+          :response_code => content.status,
           :xml           => content.body)
       end
     end
@@ -98,26 +98,52 @@ class YouTubeIt
         xml = REXML::Document.new(content.body)
         entry = xml.elements["entry"] || xml.elements["feed"]
         YouTubeIt::Model::User.new(
-          :age         => entry.elements["yt:age"] ? entry.elements["yt:age"].text : nil,
-          :company         => entry.elements["yt:company"] ? entry.elements["yt:company"].text : nil,
+          :age            => entry.elements["yt:age"] ? entry.elements["yt:age"].text : nil,
+          :username       => entry.elements["yt:username"] ? entry.elements["yt:username"].text : nil,
+          :company        => entry.elements["yt:company"] ? entry.elements["yt:company"].text : nil,
           :gender         => entry.elements["yt:gender"] ? entry.elements["yt:gender"].text : nil,
-          :hobbies         => entry.elements["yt:hobbies"] ? entry.elements["yt:hobbies"].text : nil,
-          :hometown         => entry.elements["yt:hometown"] ? entry.elements["yt:hometown"].text : nil,
-          :location         => entry.elements["yt:location"] ? entry.elements["yt:location"].text : nil,
-          :last_login         => entry.elements["yt:statistics"].attributes["lastWebAccess"],
-          :join_date         => entry.elements["published"] ? entry.elements["published"].text : nil,
+          :hobbies        => entry.elements["yt:hobbies"] ? entry.elements["yt:hobbies"].text : nil,
+          :hometown       => entry.elements["yt:hometown"] ? entry.elements["yt:hometown"].text : nil,
+          :location       => entry.elements["yt:location"] ? entry.elements["yt:location"].text : nil,
+          :last_login     => entry.elements["yt:statistics"].attributes["lastWebAccess"],
+          :join_date      => entry.elements["published"] ? entry.elements["published"].text : nil,
           :movies         => entry.elements["yt:movies"] ? entry.elements["yt:movies"].text : nil,
-          :music         => entry.elements["yt:music"] ? entry.elements["yt:music"].text : nil,
-          :occupation         => entry.elements["yt:occupation"] ? entry.elements["yt:occupation"].text : nil,
-          :relationship         => entry.elements["yt:relationship"] ? entry.elements["yt:relationship"].text : nil,
+          :music          => entry.elements["yt:music"] ? entry.elements["yt:music"].text : nil,
+          :occupation     => entry.elements["yt:occupation"] ? entry.elements["yt:occupation"].text : nil,
+          :relationship   => entry.elements["yt:relationship"] ? entry.elements["yt:relationship"].text : nil,
           :school         => entry.elements["yt:school"] ? entry.elements["yt:school"].text : nil,
-          :subscribers         => entry.elements["yt:statistics"].attributes["subscriberCount"],
-          :videos_watched         => entry.elements["yt:statistics"].attributes["videoWatchCount"],
-          :view_count         => entry.elements["yt:statistics"].attributes["viewCount"],
-          :upload_views         => entry.elements["yt:statistics"].attributes["totalUploadViews"]
+          :subscribers    => entry.elements["yt:statistics"].attributes["subscriberCount"],
+          :videos_watched => entry.elements["yt:statistics"].attributes["videoWatchCount"],
+          :view_count     => entry.elements["yt:statistics"].attributes["viewCount"],
+          :upload_views   => entry.elements["yt:statistics"].attributes["totalUploadViews"]
         )
       end
     end
+    
+    class SubscriptionFeedParser < FeedParser #:nodoc:
+
+      def parse_content(content)
+        doc = REXML::Document.new(content.body)
+        feed = doc.elements["feed"]
+        
+        subscriptions = []
+        feed.elements.each("entry") do |entry|
+          subscriptions << parse_entry(entry)
+        end
+        return subscriptions
+      end
+      
+      protected
+      
+      def parse_entry(entry)
+        YouTubeIt::Model::Subscription.new(
+          :title        => entry.elements["title"].text,
+          :id           => entry.elements["id"].text[/subscription([^<]+)/, 1].sub(':',''),
+          :published    => entry.elements["published"] ? entry.elements["published"].text : nil
+        )
+      end
+    end
+    
 
     class VideoFeedParser < FeedParser #:nodoc:
 
@@ -196,10 +222,10 @@ class YouTubeIt
         media_group.elements.each("media:thumbnail") do |thumb_element|
           # TODO: convert time HH:MM:ss string to seconds?
           thumbnails << YouTubeIt::Model::Thumbnail.new(
-                          :url => thumb_element.attributes["url"],
+                          :url    => thumb_element.attributes["url"],
                           :height => thumb_element.attributes["height"].to_i,
-                          :width => thumb_element.attributes["width"].to_i,
-                          :time => thumb_element.attributes["time"])
+                          :width  => thumb_element.attributes["width"].to_i,
+                          :time   => thumb_element.attributes["time"])
         end
 
         rating_element = entry.elements["gd:rating"]
@@ -208,10 +234,10 @@ class YouTubeIt
         rating = nil
         if rating_element
           rating_values = {
-            :min => rating_element.attributes["min"].to_i,
-            :max => rating_element.attributes["max"].to_i,
+            :min         => rating_element.attributes["min"].to_i,
+            :max         => rating_element.attributes["max"].to_i,
             :rater_count => rating_element.attributes["numRaters"].to_i,
-            :average => rating_element.attributes["average"].to_f
+            :average     => rating_element.attributes["average"].to_f
           }
 
           if extended_rating_element
@@ -235,31 +261,44 @@ class YouTubeIt
           position = where.elements["gml:Point"].elements["gml:pos"].text
           latitude, longitude = position.split(" ")
         end
+        
+        control = entry.elements["app:control"]
+        state = { :name => "published" }
+        if control && control.elements["yt:state"]
+          state = {
+            :name        => control.elements["yt:state"].attributes["name"],
+            :reason_code => control.elements["yt:state"].attributes["reasonCode"],
+            :help_url    => control.elements["yt:state"].attributes["helpUrl"],
+            :copy        => control.elements["yt:state"].text
+          }
+          
+        end
 
         YouTubeIt::Model::Video.new(
-          :video_id => video_id,
-          :published_at => published_at,
-          :updated_at => updated_at,
-          :categories => categories,
-          :keywords => keywords,
-          :title => title,
-          :html_content => html_content,
-          :author => author,
-          :description => description,
-          :duration => duration,
-          :media_content => media_content,
-          :player_url => player_url,
-          :thumbnails => thumbnails,
-          :rating => rating,
-          :view_count => view_count,
+          :video_id       => video_id,
+          :published_at   => published_at,
+          :updated_at     => updated_at,
+          :categories     => categories,
+          :keywords       => keywords,
+          :title          => title,
+          :html_content   => html_content,
+          :author         => author,
+          :description    => description,
+          :duration       => duration,
+          :media_content  => media_content,
+          :player_url     => player_url,
+          :thumbnails     => thumbnails,
+          :rating         => rating,
+          :view_count     => view_count,
           :favorite_count => favorite_count,
-          :widescreen => widescreen,
-          :noembed => noembed,
-          :racy => racy,
-          :where => where,
-          :position => position,
-          :latitude => latitude,
-          :longitude => longitude)
+          :widescreen     => widescreen,
+          :noembed        => noembed,
+          :racy           => racy,
+          :where          => where,
+          :position       => position,
+          :latitude       => latitude,
+          :longitude      => longitude,
+          :state          => state)
       end
 
       def parse_media_content (media_content_element)
@@ -271,11 +310,11 @@ class YouTubeIt
         default = (media_content_element.attributes["isDefault"] == "true")
 
         YouTubeIt::Model::Content.new(
-          :url => content_url,
-          :format => format,
-          :duration => duration,
+          :url       => content_url,
+          :format    => format,
+          :duration  => duration,
           :mime_type => mime_type,
-          :default => default)
+          :default   => default)
       end
     end
 
@@ -298,12 +337,12 @@ class YouTubeIt
           end
         end
         YouTubeIt::Response::VideoSearch.new(
-          :feed_id => feed_id || nil,
-          :updated_at => updated_at || nil,
+          :feed_id            => feed_id || nil,
+          :updated_at         => updated_at || nil,
           :total_result_count => total_result_count || nil,
-          :offset => offset || nil,
-          :max_result_count => max_result_count || nil,
-          :videos => videos)
+          :offset             => offset || nil,
+          :max_result_count   => max_result_count || nil,
+          :videos             => videos)
       end
     end
   end