youtube_it 0.0.7 → 0.0.8

data/.gitignore

@@ -0,0 +1,17 @@
+.DS_Store
+.idea
+config/database.yml
+log/*.log
+public/flash/*.swf
+tmp/**/*
+*.tmproj
+public/stylesheets/packaged/*.css
+public/javascripts/packaged/*.js
+tmp
+log
+config/*.sphinx.conf
+db/sphinx/
+sphinx/**/*
+public/packages/*
+.gitconfig
+

data/README.txt

@@ -13,6 +13,10 @@ Create a client:
   require 'youtube_it'
   client = YouTubeIt::Client.new
 
+  if you need use your dev_key for search you can make
+
+  client = YouTubeIt::Client.new(:dev_key => 'your dev key')
+
 Basic queries:
 
   client.videos_by(:query => "penguin")
@@ -40,7 +44,7 @@ Upload videos:
   You need on youtube account and developer key
   You can get these keys at the http://code.google.com/apis/youtube/dashboard/
 
-  client = YouTubeIt::Client.new("youtube_username", "youtube_passwd", "developer_key")
+  client = YouTubeIt::Client.new(:username => "youtube_username", :password =>  "youtube_passwd", :dev_key => "developer_key")
 
   Or better yet, you can use OAuth
 
@@ -64,7 +68,7 @@ Comments
 
   You can add or list comments with the following way:
 
-  client = YouTubeIt::Client.new("youtube_username", "youtube_passwd", "developer_key")
+  client = YouTubeIt::Client.new(:username => "youtube_username", :password =>  "youtube_passwd", :dev_key => "developer_key")
 
 *  get all comments:
 
@@ -78,7 +82,7 @@ Favorites
 
   You can add, delete or list your favorites videos:
 
-  client = YouTubeIt::Client.new("youtube_username", "youtube_passwd", "developer_key")
+  client = YouTubeIt::Client.new(:username => "youtube_username", :password =>  "youtube_passwd", :dev_key => "developer_key")
 
 *  get all favorites:
 
@@ -96,7 +100,7 @@ Playlist
 
   You can add, delete or list your playlists:
 
-  client = YouTubeIt::Client.new("youtube_username", "youtube_passwd", "developer_key")
+  client = YouTubeIt::Client.new(:username => "youtube_username", :password =>  "youtube_passwd", :dev_key => "developer_key")
 
 *  get all playlists:
 
@@ -137,9 +141,12 @@ Access Control List
 
 * :rate, :comment, :commentVote, :videoRespond, :list, :embed, :syndicate
 
+  with just two values:
+*    allowed or denied
+
   Example
 
-  client = YouTubeIt::Client.new("youtube_username", "youtube_passwd", "developer_key")
+  client = YouTubeIt::Client.new(:username => "youtube_username", :password =>  "youtube_passwd", :dev_key => "developer_key")
 
 * upload video with denied comments
 
@@ -172,6 +179,14 @@ Access Control List
       <%= submit_tag "Upload video" %>
     <% end %>
 
+== WideScreen Videos
+
+  if the videos has support for widescreen, you can show them with this way
+
+    video.embed_html_with_width(1280)
+
+  you can specify width or just use the default (1280)
+
 == LOGGING
 
 YouTubeIt passes all logs through the logger variable on the class itself. In Rails context, assign the Rails logger to that variable to collect the messages

data/VERSION

@@ -1,2 +1,2 @@
-0.0.7
+0.0.8
 

data/lib/youtube_it/client.rb

@@ -2,8 +2,23 @@ class YouTubeIt
   class Client
     include YouTubeIt::Logging
     # Previously this was a logger instance but we now do it globally
-    def initialize user = nil, pass = nil, dev_key = nil, client_id = 'youtube_it', legacy_debug_flag = nil
-      @user, @pass, @dev_key, @client_id = user, pass, dev_key, client_id
+
+    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]
+      else
+        puts "* warning: the method YouTubeIt::Client.new(user, passwd, dev_key) is depricated, 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.
@@ -37,6 +52,8 @@ class YouTubeIt
       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
@@ -67,13 +84,13 @@ class YouTubeIt
     # === Returns
     # YouTubeIt::Model::Video
     def video_by(vid)
-      video_id = vid =~ /^http/ ? vid : "http://gdata.youtube.com/feeds/videos/#{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}"
+      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

data/lib/youtube_it/model/video.rb

@@ -14,27 +14,27 @@ class YouTubeIt
         # Instantiates a new video format object.
         #
         # == Parameters
-        #   :format_code<Fixnum>:: The Youtube Format code of the object. 
+        #   :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          
+          @@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. 
-        #   
+        #   :format_code<Fixnum>:: The Youtube Format code of the object.
+        #
         # == Returns
         #   YouTubeIt::Model::Video::Format: Video format object
         def self.by_code(format_code)
@@ -50,77 +50,80 @@ class YouTubeIt
         # 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. 
+
+      # *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. 
+
+      # *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
-      
-      
+
+
       # Geodata
       attr_reader :where
       attr_reader :position
       attr_reader :latitude
       attr_reader :longitude
-      
+
       attr_reader :statistics
-      
+
       # Videos related to the current video.
       #
       # === Returns
@@ -128,28 +131,28 @@ class YouTubeIt
       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   
+      #   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. 
+
+      # 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
@@ -157,15 +160,23 @@ class YouTubeIt
       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
@@ -175,20 +186,39 @@ class YouTubeIt
 <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" 
+  <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('=', '/')          
+        @player_url.sub('watch?', '').sub('=', '/').sub('feature/', 'feature=')
       end
-      
+
+
     end
   end
 end
+

data/lib/youtube_it/parser.rb

@@ -83,6 +83,10 @@ class YouTubeIt
         description = media_group.elements["media:description"].text
         duration = media_group.elements["yt:duration"].attributes["seconds"].to_i
 
+        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)
@@ -142,6 +146,7 @@ class YouTubeIt
           :rating => rating,
           :view_count => view_count,
           :favorite_count => favorite_count,
+          :widescreen => widescreen,
           :noembed => noembed,
           :racy => racy,
           :where => where,

data/lib/youtube_it/request/base_search.rb

@@ -1,26 +1,27 @@
 class YouTubeIt
-  module Request #:nodoc: 
+  module Request #:nodoc:
     class BaseSearch #:nodoc:
       attr_reader :url
-      
+
       private
-      
+
       def base_url
-        "http://gdata.youtube.com/feeds/api/"                
+        "http://gdata.youtube.com/feeds/api/"
       end
-      
+
       def set_instance_variables( variables )
-        variables.each do |key, value| 
+        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? ? '' : "?#{qs}"
+        qs.empty? ? '' : (@dev_key ? "?#{qs}&key=#{@dev_key}" : "?#{qs}")
       end
     end
-    
+
   end
-end
+end
+

data/lib/youtube_it/request/standard_search.rb

@@ -1,5 +1,5 @@
 class YouTubeIt
-  module Request #:nodoc:  
+  module Request #:nodoc:
     class StandardSearch < BaseSearch #:nodoc:
       attr_reader :max_results                     # max_results
       attr_reader :order_by                        # orderby, ([relevance], viewCount, published, rating)
@@ -11,6 +11,7 @@ class YouTubeIt
                 :recently_featured, :watch_on_mobile ]
 
       def initialize(type, options={})
+        @dev_key = options[:dev_key] if options[:dev_key]
         if TYPES.include?(type)
           @max_results, @order_by, @offset, @time = nil
           set_instance_variables(options)
@@ -23,18 +24,19 @@ class YouTubeIt
       private
 
       def base_url
-        super << "standardfeeds/"        
+        super << "standardfeeds/"
       end
 
       def to_youtube_params
-        { 
-          'max-results' => @max_results, 
-          'orderby' => @order_by, 
-          'start-index' => @offset, 
-          'time' => @time 
+        {
+          'max-results' => @max_results,
+          'orderby' => @order_by,
+          'start-index' => @offset,
+          'time' => @time
         }
-      end   
+      end
     end
-    
+
   end
-end
+end
+

data/lib/youtube_it/request/user_search.rb

@@ -1,6 +1,6 @@
 class YouTubeIt
-  module Request #:nodoc:  
-    class UserSearch < BaseSearch #:nodoc:      
+  module Request #:nodoc:
+    class UserSearch < BaseSearch #:nodoc:
       attr_reader :max_results                     # max_results
       attr_reader :order_by                        # orderby, ([relevance], viewCount, published, rating)
       attr_reader :offset                          # start-index
@@ -8,9 +8,9 @@ class YouTubeIt
       def initialize(params, options={})
         @max_results, @order_by, @offset = nil
         @url = base_url
-
+        @dev_key = options[:dev_key] if options[:dev_key]
         if params == :favorites
-          @url << "#{options[:user]}/favorites" 
+          @url << "#{options[:user]}/favorites"
           set_instance_variables(options)
         elsif params[:user] && options[:favorites]
           @url << "#{params[:user]}/favorites"
@@ -20,7 +20,7 @@ class YouTubeIt
           @url << "#{params[:user]}/uploads"
           set_instance_variables(params)
         end
-        
+
         @url << build_query_params(to_youtube_params)
       end
 
@@ -38,6 +38,7 @@ class YouTubeIt
         }
       end
     end
-    
+
   end
-end
+end
+

data/lib/youtube_it/request/video_search.rb

@@ -1,5 +1,5 @@
 class YouTubeIt
-  module Request #:nodoc:    
+  module Request #:nodoc:
     class VideoSearch < BaseSearch #:nodoc:
       # From here: http://code.google.com/apis/youtube/reference.html#yt_format
       ONLY_EMBEDDABLE = 5
@@ -14,38 +14,39 @@ class YouTubeIt
       attr_reader :video_format                    # format (1=mobile devices)
       attr_reader :racy                            # racy ([exclude], include)
       attr_reader :author
-      
+
       def initialize(params={})
         # Initialize our various member data to avoid warnings and so we'll
         # automatically fall back to the youtube api defaults
-        @max_results, @order_by, 
-        @offset, @query, 
-        @response_format, @video_format, 
+        @max_results, @order_by,
+        @offset, @query,
+        @response_format, @video_format,
         @racy, @author = nil
         @url = base_url
-        
+        @dev_key = params[:dev_key] if params[:dev_key]
+
         # Return a single video (base_url + /T7YazwP8GtY)
         return @url << "/" << params[:video_id] if params[:video_id]
-        
+
         @url << "/-/" if (params[:categories] || params[:tags])
         @url << categories_to_params(params.delete(:categories)) if params[:categories]
         @url << tags_to_params(params.delete(:tags)) if params[:tags]
 
         set_instance_variables(params)
-        
+
         if( params[ :only_embeddable ] )
           @video_format = ONLY_EMBEDDABLE
         end
 
         @url << build_query_params(to_youtube_params)
       end
-      
+
       private
-      
+
       def base_url
         super << "videos"
       end
-      
+
       def to_youtube_params
         {
           'max-results' => @max_results,
@@ -59,14 +60,14 @@ class YouTubeIt
         }
       end
 
-      # Convert category symbols into strings and build the URL. GData requires categories to be capitalized. 
+      # Convert category symbols into strings and build the URL. GData requires categories to be capitalized.
       # Categories defined like: categories => { :include => [:news], :exclude => [:sports], :either => [..] }
       # or like: categories => [:news, :sports]
       def categories_to_params(categories)
         if categories.respond_to?(:keys) and categories.respond_to?(:[])
           s = ""
           s << categories[:either].map { |c| c.to_s.capitalize }.join("%7C") << '/' if categories[:either]
-          s << categories[:include].map { |c| c.to_s.capitalize }.join("/") << '/' if categories[:include]            
+          s << categories[:include].map { |c| c.to_s.capitalize }.join("/") << '/' if categories[:include]
           s << ("-" << categories[:exclude].map { |c| c.to_s.capitalize }.join("/-")) << '/' if categories[:exclude]
           s
         else
@@ -80,14 +81,15 @@ class YouTubeIt
         if tags.respond_to?(:keys) and tags.respond_to?(:[])
           s = ""
           s << tags[:either].map { |t| YouTubeIt.esc(t.to_s) }.join("%7C") << '/' if tags[:either]
-          s << tags[:include].map { |t| YouTubeIt.esc(t.to_s) }.join("/") << '/' if tags[:include]            
+          s << tags[:include].map { |t| YouTubeIt.esc(t.to_s) }.join("/") << '/' if tags[:include]
           s << ("-" << tags[:exclude].map { |t| YouTubeIt.esc(t.to_s) }.join("/-")) << '/' if tags[:exclude]
           s
         else
           tags.map { |t| YouTubeIt.esc(t.to_s) }.join("/") << '/'
-        end          
+        end
       end
-        
+
     end
   end
 end
+

data/test/test_client.rb

@@ -10,7 +10,7 @@ class TestClient < Test::Unit::TestCase
   RAILS_ENV = "test"
 
   def setup
-    @client = YouTubeIt::Client.new(ACCOUNT[:user], ACCOUNT[:passwd] , ACCOUNT[:dev_key])
+    @client = YouTubeIt::Client.new(:username => ACCOUNT[:user], :password => ACCOUNT[:passwd] , :dev_key => ACCOUNT[:dev_key])
   end
 
   def test_should_respond_to_a_basic_query
@@ -145,24 +145,23 @@ class TestClient < Test::Unit::TestCase
 
   def test_should_get_videos_for_query_search_with_categories_excluded
     video = @client.video_by("EkF4JD2rO3Q")
-    assert_equal "<object width=\"425\" height=\"350\">\n  <param name=\"movie\" value=\"http://www.youtube.com/v/EkF4JD2rO3Q&feature=youtube_gdata_player\"></param>\n  <param name=\"wmode\" value=\"transparent\"></param>\n  <embed src=\"http://www.youtube.com/v/EkF4JD2rO3Q&feature=youtube_gdata_player\" type=\"application/x-shockwave-flash\" \n   wmode=\"transparent\" width=\"425\" height=\"350\"></embed>\n</object>\n", video.embed_html
+    assert_equal "<object width=\"425\" height=\"350\">\n  <param name=\"movie\" value=\"http://www.youtube.com/v/EkF4JD2rO3Q&feature=youtube_gdata_player\"></param>\n  <param name=\"wmode\" value=\"transparent\"></param>\n  <embed src=\"http://www.youtube.com/v/EkF4JD2rO3Q&feature=youtube_gdata_player\" type=\"application/x-shockwave-flash\"\n   wmode=\"transparent\" width=\"425\" height=\"350\"></embed>\n</object>\n", video.embed_html
     assert_valid_video video
   end
 
   def test_should_get_video_from_user
     video = @client.video_by_user("chebyte","FQK1URcxmb4")
-    assert_equal "<object width=\"425\" height=\"350\">\n  <param name=\"movie\" value=\"http://www.youtube.com/v/FQK1URcxmb4&feature=youtube_gdata_player\"></param>\n  <param name=\"wmode\" value=\"transparent\"></param>\n  <embed src=\"http://www.youtube.com/v/FQK1URcxmb4&feature=youtube_gdata_player\" type=\"application/x-shockwave-flash\" \n   wmode=\"transparent\" width=\"425\" height=\"350\"></embed>\n</object>\n", video.embed_html
+    assert_equal "<object width=\"425\" height=\"350\">\n  <param name=\"movie\" value=\"http://www.youtube.com/v/FQK1URcxmb4&feature=youtube_gdata_player\"></param>\n  <param name=\"wmode\" value=\"transparent\"></param>\n  <embed src=\"http://www.youtube.com/v/FQK1URcxmb4&feature=youtube_gdata_player\" type=\"application/x-shockwave-flash\"\n   wmode=\"transparent\" width=\"425\" height=\"350\"></embed>\n</object>\n", video.embed_html
     assert_valid_video video
   end
 
-
   def test_should_always_return_a_logger
     @client = YouTubeIt::Client.new
     assert_not_nil @client.logger
   end
 
   def test_should_not_bail_if_debug_is_true
-    assert_nothing_raised { YouTubeIt::Client.new(true) }
+    assert_nothing_raised { YouTubeIt::Client.new(:debug => true) }
   end
 
   def test_should_determine_if_embeddable_video_is_embeddable
@@ -197,10 +196,10 @@ class TestClient < Test::Unit::TestCase
 
   def test_should_update_a_video
     OPTIONS[:title] = "title changed"
-    video  = @client.video_update("iKqJ8z1DPrQ", OPTIONS)
-    assert video.title == "title changed"
-    OPTIONS[:title] = "test rails"
-    @client.video_update("iKqJ8z1DPrQ", OPTIONS)
+    video  = @client.video_upload(File.open("test/test.mov"), OPTIONS)
+    updated_video  = @client.video_update(video.unique_id, OPTIONS)
+    assert updated_video.title == "title changed"
+    @client.video_delete(video.unique_id)
   end
 
   def test_should_delete_video
@@ -213,7 +212,7 @@ class TestClient < Test::Unit::TestCase
     video     = @client.video_upload(File.open("test/test.mov"), OPTIONS.merge(:comment => "denied"))
     assert_valid_video video
     doc = Nokogiri::HTML(open("http://www.youtube.com/watch?v=#{video.unique_id}"))
-    doc.css('.comments-disabled').each{|tag| assert (tag.content.strip == "Adding comments has been disabled for this video.")}
+    doc.css('.comments-disabled').each{|tag| assert (tag.content.strip == "All Comments\n        \n           Adding comments has been disabled for this video.")}
     @client.video_delete(video.unique_id)
   end
 
@@ -267,6 +266,13 @@ class TestClient < Test::Unit::TestCase
     assert @client.delete_playlist(playlist.playlist_id)
   end
 
+  def test_should_determine_if_widescreen_video_is_widescreen
+    widescreen_id = 'QqQVll-MP3I'
+
+    video = @client.video_by(widescreen_id)
+    assert video.widescreen?
+  end
+
   private
 
     def assert_valid_video (video)

data/test/test_video.rb

@@ -35,5 +35,9 @@ class TestVideo < Test::Unit::TestCase
     assert_instance_of Time, response.updated_at
   end
 
+  def test_should_scale_video_embed
+    video = YouTubeIt::Model::Video.new(:video_id => "http://gdata.youtube.com/feeds/videos/EkF4JD2rO3Q", :player_url=>"http://www.youtube.com/v/EkF4JD2rO3Q&feature=youtube_gdata_player", :widescreen => true)
+    assert_equal "<object width=\"1280\" height=\"745\">\n<param name=\"movie\" value=\"http://www.youtube.com/v/EkF4JD2rO3Q&feature=youtube_gdata_player\"></param>\n<param name=\"wmode\" value=\"transparent\"></param>\n<embed src=\"http://www.youtube.com/v/EkF4JD2rO3Q&feature=youtube_gdata_player\" type=\"application/x-shockwave-flash\"\nwmode=\"transparent\" width=\"1280\" height=\"745\"></embed>\n</object>\n", video.embed_html_with_width(1280)
+  end
 end
 

data/youtube_it.gemspec

@@ -5,18 +5,19 @@
 
 Gem::Specification.new do |s|
   s.name = %q{youtube_it}
-  s.version = "0.0.7"
+  s.version = "0.0.8"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["chebyte", "kylejginavan"]
-  s.date = %q{2010-10-18}
+  s.date = %q{2010-11-09}
   s.description = %q{Upload, delete, update, comment on youtube videos all from one gem.}
   s.email = %q{kylejginavan@gmail.com}
   s.extra_rdoc_files = [
     "README.txt"
   ]
   s.files = [
-    "History.txt",
+    ".gitignore",
+     "History.txt",
      "Manifest.txt",
      "README.txt",
      "Rakefile",

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 7
-  version: 0.0.7
+  - 8
+  version: 0.0.8
 platform: ruby
 authors: 
 - chebyte
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-18 00:00:00 -05:00
+date: 2010-11-09 00:00:00 -06:00
 default_executable: 
 dependencies: []
 
@@ -28,6 +28,7 @@ extensions: []
 extra_rdoc_files: 
 - README.txt
 files: 
+- .gitignore
 - History.txt
 - Manifest.txt
 - README.txt