vibedeck-youtube_it 0.0.1

data/lib/youtube_it/model/video.rb

@@ -0,0 +1,225 @@
+# 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 :racy
+
+      # *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
+
+
+      # Geodata
+      attr_reader :where
+      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").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").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
+        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 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
+

data/lib/youtube_it/parser.rb

@@ -0,0 +1,357 @@
+class YouTubeIt
+  module Parser #:nodoc:
+    class FeedParser #:nodoc:
+      def initialize(content)
+        @content = open(content).read
+        
+      rescue OpenURI::HTTPError => e
+        raise OpenURI::HTTPError.new(e.io.status[0],e)
+      rescue
+        @content = content
+
+      end
+
+      def parse
+        parse_content @content
+      end
+
+      def parse_videos
+        doc = REXML::Document.new(@content)
+        videos = []
+        doc.elements.each("*/entry") do |video|
+          videos << parse_entry(video)
+        end
+        videos
+      end
+    end
+
+    class CommentsFeedParser < FeedParser #:nodoc:
+      # return array of comments
+      def parse_content(content)
+        doc = REXML::Document.new(content.body)
+        feed = doc.elements["feed"]
+
+        comments = []
+        feed.elements.each("entry") do |entry|
+          comments << parse_entry(entry)
+        end
+        return comments
+      end
+
+      protected
+        def parse_entry(entry)
+          author = YouTubeIt::Model::Author.new(
+            :name => entry.elements["author"].elements["name"].text,
+            :uri  => entry.elements["author"].elements["uri"].text,
+            :thumbnail_url => entry.elements["media:thumbnail"].attributes["url"]
+          )
+          YouTubeIt::Model::Comment.new(
+            :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
+          )
+        end
+    end
+
+    class PlaylistFeedParser < FeedParser #:nodoc:
+
+      def parse_content(content)
+        xml = REXML::Document.new(content.body)
+        entry = xml.elements["entry"] || xml.elements["feed"]
+        YouTubeIt::Model::Playlist.new(
+          :title         => entry.elements["title"].text,
+          :summary       => (entry.elements["summary"] || entry.elements["media:group"].elements["media:description"]).text,
+          :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.status,
+          :xml           => content.body)
+      end
+    end
+
+    class PlaylistsFeedParser < FeedParser #:nodoc:
+
+      # return array of playlist objects
+      def parse_content(content)
+        doc = REXML::Document.new(content.body)
+        feed = doc.elements["feed"]
+        
+        playlists = []
+        feed.elements.each("entry") do |entry|
+          playlists << parse_entry(entry)
+        end
+        return playlists
+      end
+      
+      protected
+      
+      def parse_entry(entry)
+        YouTubeIt::Model::Playlist.new(
+          :title         => entry.elements["title"].text,
+          :summary       => (entry.elements["summary"] || entry.elements["media:group"].elements["media:description"]).text,
+          :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 => nil,
+          :xml           => nil)
+      end
+    end
+
+    class ProfileFeedParser < FeedParser #:nodoc:
+      def parse_content(content)
+        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,
+          :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,
+          :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,
+          :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"]
+        )
+      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:
+
+      def parse_content(content)
+        doc = REXML::Document.new(content)
+        entry = doc.elements["entry"]
+        parse_entry(entry)
+      end
+
+    protected
+      def parse_entry(entry)
+        video_id = entry.elements["id"].text
+        published_at  = entry.elements["published"] ? Time.parse(entry.elements["published"].text) : nil
+        updated_at    = entry.elements["updated"] ? Time.parse(entry.elements["updated"].text) : nil
+
+        # parse the category and keyword lists
+        categories = []
+        keywords = []
+        entry.elements.each("category") do |category|
+          # determine if  it's really a category, or just a keyword
+          scheme = category.attributes["scheme"]
+          if (scheme =~ /\/categories\.cat$/)
+            # it's a category
+            categories << YouTubeIt::Model::Category.new(
+                            :term => category.attributes["term"],
+                            :label => category.attributes["label"])
+
+          elsif (scheme =~ /\/keywords\.cat$/)
+            # it's a keyword
+            keywords << category.attributes["term"]
+          end
+        end
+
+        title = entry.elements["title"].text
+        html_content = entry.elements["content"] ? entry.elements["content"].text : nil
+
+        # parse the author
+        author_element = entry.elements["author"]
+        author = nil
+        if author_element
+          author = YouTubeIt::Model::Author.new(
+                     :name => author_element.elements["name"].text,
+                     :uri => author_element.elements["uri"].text)
+        end
+        media_group = entry.elements["media:group"]
+
+        # if content is not available on certain region, there is no media:description, media:player or yt:duration
+        description = ""
+        unless media_group.elements["media:description"].nil?
+          description = media_group.elements["media:description"].text
+        end
+
+        # if content is not available on certain region, there is no media:description, media:player or yt:duration
+        duration = 0
+        unless media_group.elements["yt:duration"].nil?
+          duration = media_group.elements["yt:duration"].attributes["seconds"].to_i
+        end
+
+        # if content is not available on certain region, there is no media:description, media:player or yt:duration
+        player_url = ""
+        unless media_group.elements["media:player"].nil?
+          player_url = media_group.elements["media:player"].attributes["url"]
+        end
+
+        unless media_group.elements["yt:aspectRatio"].nil?
+          widescreen = media_group.elements["yt:aspectRatio"].text == 'widescreen' ? true : false
+        end
+
+        media_content = []
+        media_group.elements.each("media:content") do |mce|
+          media_content << parse_media_content(mce)
+        end
+
+        # parse thumbnails
+        thumbnails = []
+        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"],
+                          :height => thumb_element.attributes["height"].to_i,
+                          :width  => thumb_element.attributes["width"].to_i,
+                          :time   => thumb_element.attributes["time"])
+        end
+
+        rating_element = entry.elements["gd:rating"]
+        extended_rating_element = entry.elements["yt:rating"]
+
+        rating = nil
+        if rating_element
+          rating_values = {
+            :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
+          }
+
+          if extended_rating_element
+            rating_values[:likes] = extended_rating_element.attributes["numLikes"].to_i
+            rating_values[:dislikes] = extended_rating_element.attributes["numDislikes"].to_i
+          end
+
+          rating = YouTubeIt::Model::Rating.new(rating_values)
+        end
+
+        if (el = entry.elements["yt:statistics"])
+          view_count, favorite_count = el.attributes["viewCount"].to_i, el.attributes["favoriteCount"].to_i
+        else
+          view_count, favorite_count = 0,0
+        end
+
+        noembed = entry.elements["yt:noembed"] ? true : false
+        racy = entry.elements["media:rating"] ? true : false
+
+        if where = entry.elements["georss:where"]
+          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,
+          :favorite_count => favorite_count,
+          :widescreen     => widescreen,
+          :noembed        => noembed,
+          :racy           => racy,
+          :where          => where,
+          :position       => position,
+          :latitude       => latitude,
+          :longitude      => longitude,
+          :state          => state)
+      end
+
+      def parse_media_content (media_content_element)
+        content_url = media_content_element.attributes["url"]
+        format_code = media_content_element.attributes["yt:format"].to_i
+        format = YouTubeIt::Model::Video::Format.by_code(format_code)
+        duration = media_content_element.attributes["duration"].to_i
+        mime_type = media_content_element.attributes["type"]
+        default = (media_content_element.attributes["isDefault"] == "true")
+
+        YouTubeIt::Model::Content.new(
+          :url       => content_url,
+          :format    => format,
+          :duration  => duration,
+          :mime_type => mime_type,
+          :default   => default)
+      end
+    end
+
+    class VideosFeedParser < VideoFeedParser #:nodoc:
+
+    private
+      def parse_content(content)
+        videos  = []
+        doc     = REXML::Document.new(content)
+        feed    = doc.elements["feed"]
+        if feed
+          feed_id            = feed.elements["id"].text
+          updated_at         = Time.parse(feed.elements["updated"].text)
+          total_result_count = feed.elements["openSearch:totalResults"].text.to_i
+          offset             = feed.elements["openSearch:startIndex"].text.to_i
+          max_result_count   = feed.elements["openSearch:itemsPerPage"].text.to_i
+
+          feed.elements.each("entry") do |entry|
+            videos << parse_entry(entry)
+          end
+        end
+        YouTubeIt::Response::VideoSearch.new(
+          :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)
+      end
+    end
+  end
+end
+

data/lib/youtube_it/record.rb

@@ -0,0 +1,12 @@
+class YouTubeIt
+  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_it/request/base_search.rb

@@ -0,0 +1,72 @@
+class YouTubeIt
+  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 : "#{YouTubeIt.esc(k)}=#{YouTubeIt.esc(v)}" }.compact.sort.join('&')
+        qs.empty? ? '' : (@dev_key ? "?#{qs}&key=#{@dev_key}" : "?#{qs}")
+      end
+    end
+
+
+    module FieldSearch
+      def default_fields
+        "id,updated,openSearch:totalResults,openSearch:startIndex,openSearch:itemsPerPage"
+      end
+
+      def fields_to_params(fields)
+        return "" unless fields
+
+        fields_param = [default_fields]
+
+        if fields[:recorded]
+          if fields[:recorded].is_a? Range
+            fields_param << "entry[xs:date(yt:recorded) > xs:date('#{formatted_date(fields[:recorded].first)}') and xs:date(yt:recorded) < xs:date('#{formatted_date(fields[:recorded].last)}')]"
+          else
+            fields_param << "entry[xs:date(yt:recorded) = xs:date('#{formatted_date(fields[:recorded])}')]"
+          end
+        end
+
+        if fields[:published]
+          if fields[:published].is_a? Range
+            fields_param << "entry[xs:dateTime(published) > xs:dateTime('#{formatted_date(fields[:published].first)}T00:00:00') and xs:dateTime(published) < xs:dateTime('#{formatted_date(fields[:published].last)}T00:00:00')]"
+          else
+            fields_param << "entry[xs:date(published) = xs:date('#{formatted_date(fields[:published])}')]"
+          end
+        end
+
+        if fields[:view_count]
+          fields_param << "entry[yt:statistics/@viewCount > #{fields[:view_count]}]"
+        end
+
+
+        return "&fields=#{URI.escape(fields_param.join(","))}"
+      end
+
+      #youtube taked dates that look like 'YYYY-MM-DD'
+      def formatted_date(date)
+        return date if date.is_a? String
+        if date.respond_to? :strftime
+          date.strftime("%Y-%m-%d")
+        else
+          ""
+        end
+      end
+    end
+  end
+end
+

data/lib/youtube_it/request/error.rb

@@ -0,0 +1,15 @@
+class UploadError < YouTubeIt::Error
+  attr_reader :code
+  def initialize(msg, code = 0)
+    super(msg)
+    @code = code
+  end
+end
+
+class AuthenticationError < YouTubeIt::Error
+  attr_reader :code
+  def initialize(msg, code = 0)
+    super(msg)
+    @code = code
+  end
+end