agiley-youtube-g 0.6.2

data/lib/youtube_g/model/author.rb

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

data/lib/youtube_g/model/category.rb

@@ -0,0 +1,11 @@
+class YouTubeG
+  module Model
+    class Category < YouTubeG::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_g/model/comment.rb

@@ -0,0 +1,20 @@
+class YouTubeG
+  module Model
+    class Comment < YouTubeG::Record
+      # *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
+      
+      # *String*:: Title for the video.
+      attr_reader :title
+      
+      # *String*:: Description of the video.
+      attr_reader :content
+      
+      # YouTubeG::Model::Author:: Information about the YouTube user who owns a piece of video content.
+      attr_reader :author      
+    end
+  end
+end

data/lib/youtube_g/model/contact.rb

@@ -0,0 +1,16 @@
+class YouTubeG
+  module Model
+    class Contact < YouTubeG::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_g/model/content.rb

@@ -0,0 +1,18 @@
+class YouTubeG
+  module Model
+    class Content < YouTubeG::Record
+      # *Boolean*:: Description of the video.
+      attr_reader :default
+      # *Fixnum*:: Length of the video in seconds.
+      attr_reader :duration
+      # YouTubeG::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_g/model/playlist.rb

@@ -0,0 +1,8 @@
+class YouTubeG
+  module Model
+    class Playlist < YouTubeG::Record
+      # *String*:: User entered description for the playlist.
+      attr_reader :description
+    end
+  end
+end

data/lib/youtube_g/model/rating.rb

@@ -0,0 +1,17 @@
+class YouTubeG
+  module Model
+    class Rating < YouTubeG::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
+    end
+  end
+end

data/lib/youtube_g/model/thumbnail.rb

@@ -0,0 +1,17 @@
+class YouTubeG
+  module Model
+    class Thumbnail < YouTubeG::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_g/model/user.rb

@@ -0,0 +1,20 @@
+class YouTubeG
+  module Model
+    class User < YouTubeG::Record
+      attr_reader :age
+      attr_reader :books
+      attr_reader :company
+      attr_reader :gender
+      attr_reader :hobbies
+      attr_reader :hometown
+      attr_reader :location
+      attr_reader :movies
+      attr_reader :music
+      attr_reader :occupation
+      attr_reader :relationship
+      attr_reader :school
+      attr_reader :description
+      attr_reader :username
+    end
+  end
+end

data/lib/youtube_g/model/video.rb

@@ -0,0 +1,204 @@
+# TODO
+#  * self atom feed
+#  * alternate youtube watch url
+#  * comments feedLink
+
+class YouTubeG
+  module Model
+    class Video < YouTubeG::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
+        #   YouTubeG::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
+        #   YouTubeG::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 = YouTubeG::Model::Video::Format.new(0, :flash)
+
+        # RTSP streaming URL for mobile video playback. H.263 video (176x144) and AMR audio.
+        RTSP = YouTubeG::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 = YouTubeG::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 = YouTubeG::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 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 YouTubeG::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
+      
+      # YouTubeG::Model::Author:: Information about the YouTube user who owns a piece of video content.
+      attr_reader :author
+      
+      # *Array*:: An array of YouTubeG::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 YouTubeG::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
+      
+      # YouTubeG::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
+      
+      
+      # Geodata
+      attr_reader :where
+      attr_reader :position
+      attr_reader :latitude
+      attr_reader :longitude
+      
+      attr_reader :statistics
+      
+      # Videos related to the current video.
+      #
+      # === Returns
+      #   YouTubeG::Response::VideoSearch
+      def related
+        YouTubeG::Parser::VideosFeedParser.new("http://gdata.youtube.com/feeds/api/videos/#{unique_id}/related").parse
+      end
+      
+      # Video responses to the current video.
+      #
+      # === Returns
+      #   YouTubeG::Response::VideoSearch   
+      def responses
+        YouTubeG::Parser::VideosFeedParser.new("http://gdata.youtube.com/feeds/api/videos/#{unique_id}/responses").parse
+      end
+
+      # Comments on the current video.
+      #
+      # === Returns
+      #   YouTubeG::Response::CommentsSearch
+      def comments_search(options={})
+        url = YouTubeG::Request::CommentsSearch.new(unique_id,options).url
+        YouTubeG::Parser::CommentsFeedParser.new(url).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]
+      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
+      
+      # Provides a URL and various other types of information about a video.
+      # 
+      # === Returns
+      #   YouTubeG::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
+
+      # 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('=', '/')          
+      end
+      
+    end
+  end
+end

data/lib/youtube_g/parser.rb

@@ -0,0 +1,252 @@
+class YouTubeG
+  module Parser #:nodoc:
+    class FeedParser #:nodoc:
+      def initialize(url)
+        @url = url
+      end
+      
+      def parse
+        parse_content open(@url).read
+      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
+        
+        if entry.elements["app:control/yt:state"]          
+          # yt:state generally indicates a video is unavailable
+          # see: http://code.google.com/apis/youtube/2.0/reference.html#youtube_data_api_tag_yt:state
+          unless entry.elements["app:control/yt:state[@name='restricted']"]
+            # the exception I've found is for *restricted* videos, which generally
+            # means they're not available for viewing on a device other than a web browser
+            # or in a certain region
+            return nil
+          end
+        end
+        
+        # if there's no content we're going to puke later
+        unless entry.elements['content']
+          return nil
+        end
+        
+        published_at = Time.parse(entry.elements["published"].text)
+        updated_at = Time.parse(entry.elements["updated"].text)
+
+        # 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 << YouTubeG::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"].text
+
+        # parse the author
+        author_element = entry.elements["author"]
+        author = nil
+        if author_element
+          author = YouTubeG::Model::Author.new(
+                     :name => author_element.elements["name"].text,
+                     :uri => author_element.elements["uri"].text)
+        end
+      
+        media_group = entry.elements["media:group"]
+        description = media_group.elements["media:description"].text
+        duration = media_group.elements["yt:duration"].attributes["seconds"].to_i
+
+        media_content = []
+        media_group.elements.each("media:content") do |mce|
+          media_content << parse_media_content(mce)
+        end
+
+        player_url = media_group.elements["media:player"].attributes["url"]
+
+        # parse thumbnails
+        thumbnails = []
+        media_group.elements.each("media:thumbnail") do |thumb_element|
+          # TODO: convert time HH:MM:ss string to seconds?
+          thumbnails << YouTubeG::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"]
+        rating = nil
+        if rating_element
+          rating = YouTubeG::Model::Rating.new(
+                     :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)
+        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
+
+        YouTubeG::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,
+          :noembed => noembed,
+          :racy => racy,
+          :where => where,
+          :position => position,
+          :latitude => latitude,
+          :longitude => longitude)
+      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 = YouTubeG::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")
+
+        YouTubeG::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)
+        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
+          
+          videos = []
+          feed.elements.each("entry") do |entry|
+            if video = parse_entry(entry)
+              videos << video
+            end
+          end
+
+          YouTubeG::Response::VideoSearch.new(
+            :feed_id => feed_id,
+            :updated_at => updated_at,
+            :total_result_count => total_result_count,
+            :offset => offset,
+            :max_result_count => max_result_count,
+            :videos => videos)
+        else
+          entry = doc.elements["entry"]
+          video = parse_entry(entry) if (entry)
+        end
+      end
+    end
+
+    class CommentsFeedParser < FeedParser
+    
+      def parse_content(content)
+        doc = REXML::Document.new(content)
+        feed = doc.elements['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
+        
+        comments = []
+        feed.elements.each('entry') do |entry|
+          comments << parse_entry(entry)
+        end
+        YouTubeG::Response::CommentsSearch.new(
+          :feed_id            => feed_id,
+          :updated_at         => updated_at,
+          :total_result_count => total_result_count,
+          :offset             => offset,
+          :max_result_count   => max_result_count,
+          :comments           => comments)
+      end
+      
+    private
+      def parse_entry(entry)
+        comment_id = entry.elements["id"].text
+        
+        published_at = Time.parse(entry.elements["published"].text)
+        updated_at   = Time.parse(entry.elements["updated"].text)
+
+        title   = entry.elements["title"].text
+        content = entry.elements["content"].text
+
+        # parse the author
+        author_element = entry.elements["author"]
+        author = nil
+        if author_element
+          author = YouTubeG::Model::Author.new(
+                     :name => author_element.elements["name"].text,
+                     :uri => author_element.elements["uri"].text)
+        end
+      
+
+        comment = YouTubeG::Model::Comment.new(
+          :published_at => published_at,
+          :updated_at   => updated_at,
+          :title        => title,
+          :content      => content,
+          :author       => author)
+        return comment
+      end
+    end
+  end 
+end