youtube_it 0.0.1

data/History.txt

@@ -0,0 +1,52 @@
+* Implement video update and video delete in Upload
+* Refactor the uploader slightly
+* Use Builder to generate XML packets
+* Use a faster Camping-based URL escaper (also avoid cgi.rb)
+* Removed the logger nightmare, use YouTubeIt.logger for everything whatever that may be
+* Use streams for file uploads instead of in-memory strings
+
+== 0.5.0 / 2009-01-07
+
+* Fixed bug in user favorites (thanks Pius Uzamere)
+
+== 0.4.9.9 / 2008-09-01
+
+* Add Geodata information (thanks Jose Galisteo)
+* Added :page and :per_page options, this allows easier usage of the will_paginate
+  plugin with the library. The :offset and :max_results options are no longer available. [Daniel Insley]
+* Added ability to get video responses on the instances of the YouTube::Model::Video object. [Daniel Insley]
+* Added and improved the existing documentation [Daniel Insley]
+* Fixed usage of deprecated yt:racy, now using media:rating [Daniel Insley]
+* Renamed can_embed? method to embeddable? [Daniel Insley]
+* Added ability for padingation and ordering on standard feeds. [Daniel Insley]
+* Add error-handling for video upload errors. [FiXato]
+* Add error-handling for authentication errors from YouTube during video upload. [FiXato]
+* Add support for making videos private upon video upload. [FiXato]
+* Fix issue with REXML parsing of video upload response. [FiXato]
+* Fix issue with response code comparison. [FiXato]
+* Authcode is now retrieved for video uploads. [FiXato]
+* Add basic support for uploading videos [thanks Joe Damato]
+* Add basic support for related videos [tmm1]
+* Improve docs for order_by attribute [thanks Jason Arora]
+* Added support for the "racy" parameter (choices are "include" or "exclude") [thanks Jason Arora]
+* Add missing attribute reader for description [tmm1]
+* Fix issue with missing yt:statistics and viewCount [tmm1]
+* Allow Client#video_by to take either a url or a video id [tmm1]
+
+== 0.4.1 / 2008-02-11
+
+* Added 3GPP video format [shane]
+* Fixed tests [shane]
+
+== 0.4.0 / 2007-12-18
+
+* Fixed API projection in search URL [Pete Higgins]
+* Fixed embeddable video searching [Pete Higgins]
+* Fixed video embeddable detection [Pete Higgins]
+* Fixed unique id hyphen detection [Pete Higgins, Chris Taggart]
+
+== 0.3.0 / 2007-09-17
+
+* Initial public release
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,32 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+TODO.txt
+lib/youtube_it.rb
+lib/youtube_it/chain_io.rb
+lib/youtube_it/client.rb
+lib/youtube_it/model/author.rb
+lib/youtube_it/model/category.rb
+lib/youtube_it/model/contact.rb
+lib/youtube_it/model/content.rb
+lib/youtube_it/model/playlist.rb
+lib/youtube_it/model/rating.rb
+lib/youtube_it/model/thumbnail.rb
+lib/youtube_it/model/user.rb
+lib/youtube_it/model/video.rb
+lib/youtube_it/parser.rb
+lib/youtube_it/record.rb
+lib/youtube_it/request/base_search.rb
+lib/youtube_it/request/standard_search.rb
+lib/youtube_it/request/user_search.rb
+lib/youtube_it/request/video_search.rb
+lib/youtube_it/request/video_upload.rb
+lib/youtube_it/response/video_search.rb
+lib/youtube_it/version.rb
+test/helper.rb
+test/test_chain_io.rb
+test/test_client.rb
+test/test_video.rb
+test/test_video_search.rb
+

data/README.txt

@@ -0,0 +1,123 @@
+== DESCRIPTION:
+
+youtube_it is a pure Ruby client for the YouTube GData API. It provides an easy
+way to access the latest YouTube video search results from your own programs.
+In comparison with the earlier Youtube search interfaces, this new API and
+library offers much-improved flexibility around executing complex search
+queries to obtain well-targeted video search results.
+
+== SYNOPSIS:
+
+Create a client:
+
+  require 'youtube_it'
+  client = YouTubeIt::Client.new
+
+Basic queries:
+
+  client.videos_by(:query => "penguin")
+  client.videos_by(:query => "penguin", :page => 2, :per_page => 15)
+  client.videos_by(:tags => ['tiger', 'leopard'])
+  client.videos_by(:categories => [:news, :sports])
+  client.videos_by(:categories => [:news, :sports], :tags => ['soccer', 'football'])
+  client.videos_by(:user => 'liz')
+  client.videos_by(:favorites, :user => 'liz')
+  client.video_by("FQK1URcxmb4")
+  client.video_by("chebyte","FQK1URcxmb4")
+
+Standard feeds:
+
+  client.videos_by(:most_viewed)
+  client.videos_by(:most_linked, :page => 3)
+  client.videos_by(:top_rated, :time => :today)
+
+Advanced queries (with boolean operators OR (either), AND (include), NOT (exclude)):
+
+  client.videos_by(:categories => { :either => [:news, :sports], :exclude => [:comedy] }, :tags => { :include => ['football'], :exclude => ['soccer'] })
+
+
+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")
+
+* upload video
+
+  client.video_upload(File.open("test.mov"), :title => "test",:description => 'some description', :category => 'People',:keywords => %w[cool blah test])
+
+* update video
+
+  client.video_update("FQK1URcxmb4", :title => "new test",:description => 'new description', :category => 'People',:keywords => %w[cool blah test])
+
+* delete video
+
+  client.video_delete("FQK1URcxmb4")
+
+
+== Upload videos from browser:
+
+ For upload a video from browser you need make a form upload with the followings params
+
+    upload_token(params, nexturl)
+
+    params  => params like :title => "title", :description => "description", :category => "People", :tags => ["test"]
+    nexturl => redirect to this url after upload
+
+   Example
+
+   Controller:
+
+    def upload
+      @upload_info = YouTubeIt::Client.new.upload_token(params, videos_url)
+    end
+
+   Views: upload.html.erb
+
+    <% form_tag @upload_info[:url], :multipart => true do %>
+      <%= hidden_field_tag :token, @upload_info[:token] %>
+      <%= label_tag :file %>
+      <%= file_field_tag :file %>
+      <%= submit_tag "Upload video" %>
+    <% end %>
+
+== 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
+(don't forget to set the level to debug):
+
+ YouTubeIt.logger = RAILS_DEFAULT_LOGGER
+ RAILS_DEFAULT_LOGGER.level = Logger::DEBUG
+
+== REQUIREMENTS:
+
+* builder gem
+
+== INSTALL:
+
+* sudo gem install youtube_it
+== LICENSE:
+
+MIT License
+
+Copyright (c) 2007 Shane Vitarana and Walter Korman
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/Rakefile

@@ -0,0 +1,59 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "youtube_it"
+    gem.summary = %Q{the one stop shop for working with youtube apis}
+    gem.description = %Q{the one stop shop for working with youtube apis}
+    gem.email = "maurotorres@gmail.com"
+    gem.homepage = "http://github.com/kylejginavan/youtube_it"
+    gem.authors = ["Mauro Torres & Kyle Ginavan"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "youtube_it (or a dependency) not available. Install it with: gem install youtube_it"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'spec'
+  test.pattern = 'spec/**/*_spec.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'spec'
+    test.pattern = 'spec/**/*_spec.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "constantations #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'spec/rake/spectask'
+desc "Run all specs"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_opts = ['--colour --format progress --loadby mtime --reverse']
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+

data/TODO.txt

@@ -0,0 +1,16 @@
+[ ] stub out http request/response cycle for tests
+[ ] allow specifying values as single items where you don't need to wrap in a list, e.g. :tags => :chickens instead of :tags => [ 'chickens' ]
+[ ] make sure symbols will work as well as tags everywhere (again, :tags => :chickens is same as :tags => 'chickens')
+[ ] figure out better structure for class/file (either rename request/video_search.rb or split into one class per file again)
+[ ] restore spaces after method def names
+[ ] use a proxy for testing with static sample result xml so we have repeatable tests
+[ ] Clean up tests using Shoulda to define contexts
+[ ] Allow :category and :categories for query DSL
+[ ] Exception handling
+
+== API Features TODO
+
+[ ] Profile feed parsing
+[ ] Playlist feeds
+[ ] User subscriptions
+[ ] Video comments

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/youtube_it.rb

@@ -0,0 +1,67 @@
+require 'logger'
+require 'open-uri'
+require 'net/https'
+require 'digest/md5'
+require 'rexml/document'
+require 'builder'
+
+class YouTubeIt
+  
+  # Base error class for the extension
+  class Error < RuntimeError
+  end
+  
+  # URL-escape a string. Stolen from Camping (wonder how many Ruby libs in the wild can say the same)
+  def self.esc(s) #:nodoc:
+    s.to_s.gsub(/[^ \w.-]+/n){'%'+($&.unpack('H2'*$&.size)*'%').upcase}.tr(' ', '+')
+  end
+  
+  # Set the logger for the library
+  def self.logger=(any_logger)
+    @logger = any_logger
+  end
+
+  # Get the logger for the library (by default will log to STDOUT). TODO: this is where we grab the Rails logger too
+  def self.logger
+    @logger ||= create_default_logger
+  end
+  
+  # Gets mixed into the classes to provide the logger method
+  module Logging #:nodoc:
+    
+    # Return the base logger set for the library
+    def logger
+      YouTubeIt.logger
+    end
+  end
+    
+  private
+    def self.create_default_logger
+      logger = Logger.new(STDOUT)
+      logger.level = Logger::DEBUG
+      logger
+    end
+end
+
+%w( 
+  version
+  client
+  record
+  parser
+  model/author
+  model/category
+  model/contact
+  model/content
+  model/playlist
+  model/rating
+  model/thumbnail
+  model/user
+  model/video
+  request/base_search
+  request/user_search
+  request/standard_search
+  request/video_upload
+  request/video_search
+  response/video_search
+  chain_io
+).each{|m| require File.dirname(__FILE__) + '/youtube_it/' + m }

data/lib/youtube_it/chain_io.rb

@@ -0,0 +1,71 @@
+require 'delegate'
+#:stopdoc:
+
+# Stream wrapper that reads IOs in succession. Can be fed to Net::HTTP as post body stream. We use it internally to stream file content
+# instead of reading whole video files into memory. Strings passed to the constructor will be wrapped in StringIOs. By default it will auto-close
+# file handles when they have been read completely to prevent our uploader from leaking file handles
+#
+# chain = ChainIO.new(File.open(__FILE__), File.open('/etc/passwd'), "abcd")
+class YouTubeIt::ChainIO
+  attr_accessor :autoclose
+
+  def initialize(*any_ios)
+    @autoclose = true
+    @chain = any_ios.flatten.map{|e| e.respond_to?(:read)  ? e : StringIO.new(e.to_s) }
+  end
+
+  def read(buffer_size = 1024)
+    # Read off the first element in the stack
+    current_io = @chain.shift
+    return false if !current_io
+    
+    buf = current_io.read(buffer_size)
+    if !buf && @chain.empty? # End of streams
+      release_handle(current_io) if @autoclose
+      false
+    elsif !buf # This IO is depleted, but next one is available
+      release_handle(current_io) if @autoclose
+      read(buffer_size)
+    elsif buf.length < buffer_size # This IO is depleted, but we were asked for more
+      release_handle(current_io) if @autoclose
+      buf + (read(buffer_size - buf.length) || '') # and recurse
+    else # just return the buffer
+      @chain.unshift(current_io) # put the current back
+      buf
+    end
+  end
+  
+  # Predict the length of all embedded IOs. Will automatically send file size.  
+  def expected_length
+    @chain.inject(0) do | len, io |
+      if io.respond_to?(:length)
+        len + (io.length - io.pos)
+      elsif io.is_a?(File)
+        len + File.size(io.path) - io.pos
+      else
+        raise "Cannot predict length of #{io.inspect}"
+      end
+    end
+  end
+    
+  private
+    def release_handle(io)
+      io.close if io.respond_to?(:close)
+    end
+end
+  
+# Net::HTTP only can send chunks of 1024 bytes. This is very inefficient, so we have a spare IO that will send more when asked for 1024.
+# We use delegation because the read call is recursive.
+class YouTubeIt::GreedyChainIO < DelegateClass(YouTubeIt::ChainIO)
+  BIG_CHUNK = 512 * 1024 # 500 kb
+  
+  def initialize(*with_ios)
+    __setobj__(YouTubeIt::ChainIO.new(with_ios))
+  end
+  
+  def read(any_buffer_size)
+    __getobj__.read(BIG_CHUNK)
+  end
+end
+
+#:startdoc:

data/lib/youtube_it/client.rb

@@ -0,0 +1,114 @@
+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
+    end
+
+
+    # Retrieves an array of standard feed, custom query, or user videos.
+    #
+    # === Parameters
+    # If fetching videos for a standard feed:
+    #   params<Symbol>:: Accepts a symbol of :top_rated, :top_favorites, :most_viewed,
+    #                    :most_popular, :most_recent, :most_discussed, :most_linked,
+    #                    :most_responded, :recently_featured, and :watch_on_mobile.
+    #
+    #   You can find out more specific information about what each standard feed provides
+    #   by visiting: http://code.google.com/apis/youtube/reference.html#Standard_feeds
+    #
+    #   options<Hash> (optional)::  Accepts the options of :time, :page (default is 1),
+    #                               and :per_page (default is 25). :offset and :max_results
+    #                               can also be passed for a custom offset.
+    #
+    # If fetching videos by tags, categories, query:
+    #   params<Hash>:: Accepts the keys :tags, :categories, :query, :order_by,
+    #                  :author, :racy, :response_format, :video_format, :page (default is 1),
+    #                  and :per_page(default is 25)
+    #
+    #   options<Hash>:: Not used. (Optional)
+    #
+    # If fetching videos for a particular user:
+    #   params<Hash>:: Key of :user with a value of the username.
+    #   options<Hash>:: Not used. (Optional)
+    # === Returns
+    # YouTubeIt::Response::VideoSearch
+    def videos_by(params, options={})
+      request_params = params.respond_to?(:to_hash) ? params : options
+      request_params[:page] = integer_or_default(request_params[:page], 1)
+
+      unless request_params[:max_results]
+        request_params[:max_results] = integer_or_default(request_params[:per_page], 25)
+      end
+
+      unless request_params[:offset]
+        request_params[:offset] = calculate_offset(request_params[:page], request_params[:max_results] )
+      end
+
+      if params.respond_to?(:to_hash) and not params[:user]
+        request = YouTubeIt::Request::VideoSearch.new(request_params)
+      elsif (params.respond_to?(:to_hash) && params[:user]) || (params == :favorites)
+        request = YouTubeIt::Request::UserSearch.new(params, request_params)
+      else
+        request = YouTubeIt::Request::StandardSearch.new(params, request_params)
+      end
+
+      logger.debug "Submitting request [url=#{request.url}]."
+      parser = YouTubeIt::Parser::VideosFeedParser.new(request.url)
+      parser.parse
+    end
+
+    # Retrieves a single YouTube video.
+    #
+    # === Parameters
+    #   vid<String>:: The ID or URL of the video that you'd like to retrieve.
+    #   user<String>:: The user that uploaded the video that you'd like to retrieve.
+    #
+    # === Returns
+    # YouTubeIt::Model::Video
+    def video_by(vid)
+      video_id = vid =~ /^http/ ? vid : "http://gdata.youtube.com/feeds/videos/#{vid}"
+      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}"
+      parser = YouTubeIt::Parser::VideoFeedParser.new(video_id)
+      parser.parse
+    end
+
+    def video_upload(data, opts = {})
+      client.upload(data, opts)
+    end
+
+    def video_update(video_id, opts = {})
+      client.update(video_id, opts)
+    end
+
+    def video_delete(video_id)
+      client.delete(video_id)
+    end
+
+    def upload_token(options, nexturl = "http://www.youtube.com/my_videos")
+      client.get_upload_token(options, nexturl)
+    end
+
+    private
+
+    def client
+      @client ||= YouTubeIt::Upload::VideoUpload.new(@user, @pass, @dev_key)
+    end
+
+    def calculate_offset(page, per_page)
+      page == 1 ? 1 : ((per_page * page) - per_page + 1)
+    end
+
+    def integer_or_default(value, default)
+      value = value.to_i
+      value > 0 ? value : default
+    end
+  end
+end
+