nddrylliog_youtube_it 2.1.4

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_oauth2.rb

@@ -0,0 +1,13 @@
+module Faraday
+  class Request::OAuth2 < Faraday::Middleware
+    def call(env)
+      env[:request_headers]['Authorization'] = "Bearer #{@access_token.token}"
+
+      @app.call(env)
+    end
+
+    def initialize(app, access_token)
+      @app, @access_token = app, access_token
+    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/activity.rb

@@ -0,0 +1,17 @@
+class YouTubeIt
+  module Model
+    class Activity < YouTubeIt::Record
+      # Attributes common to multiple activity types
+      attr_reader :type, :author, :videos, :video_id, :time
+      
+      # video_rated
+      attr_reader :user_rating, :video_rating
+      
+      # video_commented
+      attr_reader :comment_thread_url, :video_url
+      
+      # friend_added and user_subscription_added
+      attr_reader :username
+    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,19 @@
+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
+      
+      # *String*:: The Youtube title of the contact.
+      attr_reader :title
+    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/message.rb

@@ -0,0 +1,12 @@
+class YouTubeIt
+  module Model
+    class Message < YouTubeIt::Record
+      attr_reader :id, :name, :title, :summary, :published
+      
+      def content
+        # This tag contains the same value as the <summary> tag.
+        self.summary
+      end
+    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,28 @@
+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
+      attr_reader :avatar
+      attr_reader :insight_uri
+    end
+  end
+end

data/lib/youtube_it/model/video.rb

@@ -0,0 +1,243 @@
+# TODO
+#  * self atom feed
+#  * alternate youtube watch url
+#  * comments feedLink
+
+class YouTubeIt
+  module Model
+    class Video < YouTubeIt::Record
+      # Describes the various file formats in which a Youtube video may be
+      # made available and allows looking them up by format code number.
+      class Format
+        @@formats = Hash.new
+
+        # Instantiates a new video format object.
+        #
+        # == Parameters
+        #   :format_code<Fixnum>:: The Youtube Format code of the object.
+        #   :name<Symbol>:: The name of the format
+        #
+        # == Returns
+        #   YouTubeIt::Model::Video::Format: Video format object
+        def initialize(format_code, name)
+          @format_code = format_code
+          @name = name
+
+          @@formats[format_code] = self
+        end
+
+        # Allows you to get the video format for a specific format code.
+        #
+        # A full list of format codes is available at:
+        #
+        # http://code.google.com/apis/youtube/reference.html#youtube_data_api_tag_media:content
+        #
+        # == Parameters
+        #   :format_code<Fixnum>:: The Youtube Format code of the object.
+        #
+        # == Returns
+        #   YouTubeIt::Model::Video::Format: Video format object
+        def self.by_code(format_code)
+          @@formats[format_code]
+        end
+
+        # Flash format on YouTube site. All videos are available in this format.
+        FLASH = YouTubeIt::Model::Video::Format.new(0, :flash)
+
+        # RTSP streaming URL for mobile video playback. H.263 video (176x144) and AMR audio.
+        RTSP = YouTubeIt::Model::Video::Format.new(1, :rtsp)
+
+        # HTTP URL to the embeddable player (SWF) for this video. This format
+        # is not available for a video that is not embeddable.
+        SWF = YouTubeIt::Model::Video::Format.new(5, :swf)
+
+        # RTSP streaming URL for mobile video playback. MPEG-4 SP video (up to 176x144) and AAC audio.
+        THREE_GPP = YouTubeIt::Model::Video::Format.new(6, :three_gpp)
+      end
+
+      # *Fixnum*:: Duration of a video in seconds.
+      attr_reader :duration
+
+      # *Boolean*:: Specifies that a video may or may not be 16:9 ratio.
+      attr_reader :widescreen
+
+      # *Boolean*:: Specifies that a video may or may not be embedded on other websites.
+      attr_reader :noembed
+
+      # *Fixnum*:: Specifies the order in which the video appears in a playlist.
+      attr_reader :position
+
+      # *Boolean*:: Specifies that a video is flagged as adult or not.
+      attr_reader :safe_search
+
+      # *String*: Specifies a URI that uniquely and permanently identifies the video.
+      attr_reader :video_id
+
+      # *Time*:: When the video was published on Youtube.
+      attr_reader :published_at
+
+      # *Time*:: When the video's data was last updated.
+      attr_reader :updated_at
+
+      # *Array*:: A array of YouTubeIt::Model::Category objects that describe the videos categories.
+      attr_reader :categories
+
+      # *Array*:: An array of words associated with the video.
+      attr_reader :keywords
+
+      # *String*:: Description of the video.
+      attr_reader :description
+
+      # *String*:: Title for the video.
+      attr_reader :title
+
+      # *String*:: Description of the video.
+      attr_reader :html_content
+
+      # YouTubeIt::Model::Author:: Information about the YouTube user who owns a piece of video content.
+      attr_reader :author
+
+      # *Array*:: An array of YouTubeIt::Model::Content objects describing the individual media content data available for this video.  Most, but not all, videos offer this.
+      attr_reader :media_content
+
+      # *Array*:: An array of YouTubeIt::Model::Thumbnail objects that contain information regarding the videos thumbnail images.
+      attr_reader :thumbnails
+
+      # *String*:: The link to watch the URL on YouTubes website.
+      attr_reader :player_url
+
+      # YouTubeIt::Model::Rating:: Information about the videos rating.
+      attr_reader :rating
+
+      # *Fixnum*:: Number of times that the video has been viewed
+      attr_reader :view_count
+
+      # *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
+
+      # *String*:: URI for insight for this video, if present; nil otherwise
+      attr_reader :insight_uri
+
+
+      # Geodata
+      attr_reader :position
+      attr_reader :latitude
+      attr_reader :longitude
+
+      # Videos related to the current video.
+      #
+      # === Returns
+      #   YouTubeIt::Response::VideoSearch
+      def related
+        YouTubeIt::Parser::VideosFeedParser.new("http://gdata.youtube.com/feeds/api/videos/#{unique_id}/related?v=2").parse
+      end
+      # Video responses to the current video.
+      #
+      # === Returns
+      #   YouTubeIt::Response::VideoSearch
+      def responses
+        YouTubeIt::Parser::VideosFeedParser.new("http://gdata.youtube.com/feeds/api/videos/#{unique_id}/responses?v=2").parse
+      end
+      # The ID of the video, useful for searching for the video again without having to store it anywhere.
+      # A regular query search, with this id will return the same video.
+      #
+      # === Example
+      #   >> video.unique_id
+      #   => "ZTUVgYoeN_o"
+      #
+      # === Returns
+      #   String: The Youtube video id.
+      def unique_id
+        @unique_id || video_id[/videos\/([^<]+)/, 1] || video_id[/video\:([^<]+)/, 1]
+      end
+
+      # Allows you to check whether the video can be embedded on a webpage.
+      #
+      # === Returns
+      #   Boolean: True if the video can be embedded, false if not.
+      def embeddable?
+        not @noembed
+      end
+
+      # Allows you to check whether the video is widescreen (16:9) or not.
+      #
+      # === Returns
+      # Boolean: True if the video is (approximately) 16:9, false if not.
+      def widescreen?
+        @widescreen
+      end
+
+      # Provides a URL and various other types of information about a video.
+      #
+      # === Returns
+      #   YouTubeIt::Model::Content: Data about the embeddable video.
+      def default_media_content
+        @media_content.find { |c| c.is_default? }
+      end
+
+      # Gives you the HTML to embed the video on your website.
+      #
+      # === Returns
+      #   String: The HTML for embedding the video on your website.
+      def embed_html(width = 425, height = 350)
+        <<EDOC
+<object width="#{width}" height="#{height}">
+  <param name="movie" value="#{embed_url}"></param>
+  <param name="wmode" value="transparent"></param>
+  <embed src="#{embed_url}" type="application/x-shockwave-flash"
+   wmode="transparent" width="#{width}" height="#{height}"></embed>
+</object>
+EDOC
+      end
+
+            # Gives you the HTML 5 to embed the video on your website.
+            # Usefull for mobile that not support flash but has html5 browser
+            # === Returns
+            #   String: The HTML for embedding the video on your website.
+            def embed_html5(params = {})
+              opts = {:class  => params[:class]  || "",
+                      :id     => params[:id]     || "",
+                      :width  => params[:width]  || "425",
+                      :height => params[:height] || "350",
+                      :frameborder => params[:frameborder] || "0",
+                      :url_params => params[:url_params] || {}
+                      }
+              url_opts = opts[:url_params].empty? ? "" : "?#{Rack::Utils::build_query(opts[:url_params])}"
+              <<EDOC
+<iframe class="#{opts[:class]}" id="#{opts[:id]}" type="text/html" width="#{opts[:width]}" height="#{opts[:height]}" src="http://www.youtube.com/embed/#{unique_id}#{url_opts}" frameborder="#{opts[:frameborder]}"></iframe>
+EDOC
+            end
+
+      # Gives you the HTML to embed the video on your website.
+      #
+      # === Returns
+      # String: The HTML for embedding the video on your website.
+      def embed_html_with_width(width = 1280)
+        height = (widescreen? ? width * 9/16 : width * 3/4) + 25
+
+        <<EDOC
+<object width="#{width}" height="#{height}">
+<param name="movie" value="#{embed_url}"></param>
+<param name="wmode" value="transparent"></param>
+<embed src="#{embed_url}" type="application/x-shockwave-flash"
+wmode="transparent" width="#{width}" height="#{height}"></embed>
+</object>
+EDOC
+      end
+
+      # The URL needed for embedding the video in a page.
+      #
+      # === Returns
+      #   String: Absolute URL for embedding video
+      def embed_url
+        @player_url.sub('watch?', '').sub('=', '/').sub('feature/', 'feature=')
+      end
+
+
+    end
+  end
+end
+