mikedamage-ruby_tube 0.2.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,7 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+._*
+*~

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Mike Green
+
+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/README.rdoc

@@ -0,0 +1,11 @@
+= ruby_tube
+
+RubyTube is a simple library built to interact with YouTube through ActiveRecord-like methods (like find, count, all, etc).
+
+It's far from polished, and not all its methods are AR-like. It does provide a relatively simple interface for uploading videos to YouTube and retrieving info on the videos you've uploaded.
+
+Yet another gem I don't expect anyone to actually use - I just built it because I needed basic YouTube functionality for a Rails app I'm working on.
+
+== Copyright
+
+Copyright (c) 2009 Mike Green. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "ruby_tube"
+    gem.summary = %Q{TODO}
+    gem.email = "mike.is.green@gmail.com"
+    gem.homepage = "http://github.com/mikedamage/ruby_tube"
+    gem.authors = ["Mike Green"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.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 :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "ruby_tube #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.2.1

data/lib/ruby_tube.rb

@@ -0,0 +1,167 @@
+require "ostruct"
+require File.join(File.dirname(__FILE__), "yt_client.rb")
+require File.join(File.dirname(__FILE__), "yt_video.rb")
+require File.join(File.dirname(__FILE__), "yt_comment.rb")
+require File.join(File.dirname(__FILE__), "yt_rating.rb")
+
+class RubyTube < YTClient
+	
+	def initialize(username, password, key, options={:refresh=>300})
+		super(username, password, key, options)
+	end
+	
+	def find(id)
+		xml = check_video(id)
+		entry = (xml/"entry")
+		status = (xml/"yt:state").empty? ? "ok" : (xml/"yt:state").attr("name")
+		video = YTVideo.new({
+			:id => (entry/"yt:videoid").text,
+			:title => (entry/"title").text,
+			:description => (entry/"media:description").text,
+			:keywords => (entry/"media:keywords").text,
+			:duration => (entry/"yt:duration").attr("seconds").to_i,
+			:player_uri => (entry/"link[@rel='alternate']").attr("href"),
+			:ratings_uri => (entry/"link[@rel$='ratings']").attr("href"),
+			:comments_uri => (entry/"gd:comments").search("gd:feedlink").attr("href"),
+			:comment_count => (entry/"gd:comments").search("gd:feedlink").attr("countHint").to_i,
+			:published_at => Time.parse((entry/"published").text),
+			:updated_at => Time.parse((entry/"updated").text),
+			:thumbnails => {
+				:small => {
+					:url => (entry/"media:thumbnail[@url$='default.jpg']").attr("url"),
+					:width => 120,
+					:height => 90
+				},
+				:large => {
+					:url => (entry/"media:thumbnail[@url$='hqdefault.jpg]").attr("url"),
+					:width => 480,
+					:height => 360
+				}
+			},
+			:view_count => (entry/"yt:statistics").empty? ? 0 : (entry/"yt:statistics").attr("viewCount"),
+			:favorite_count => (entry/"yt:statistics").empty? ? 0 : (entry/"yt:statistics").attr("favoriteCount"),
+			:comments => comments((entry/"yt:videoid").text),
+			:ratings => ratings((entry/"yt:videoid").text),
+			:status => status,
+			:thumbnails => process_thumbnail_urls(entry)
+		})
+		return video
+	end
+	
+	def find_all
+		@all = all()
+		videos = Array.new
+		(all/"entry").each do |entry|
+			status = (entry/"yt:state").empty? ? "ok" : (entry/"yt:state").attr("name")
+			video = YTVideo.new({
+				:id => (entry/"yt:videoid").text,
+				:title => (entry/"title").text,
+				:description => (entry/"media:description").text,
+				:keywords => (entry/"media:keywords").text,
+				:duration => (entry/"yt:duration").attr("seconds").to_i,
+				:player_uri => (entry/"link[@rel='alternate']").attr("href"),
+				:ratings_uri => (entry/"link[@rel$='ratings']").attr("href"),
+				:comments_uri => (entry/"gd:comments").search("gd:feedlink").attr("href"),
+				:comment_count => (entry/"gd:comments").search("gd:feedlink").attr("countHint").to_i,
+				:published_at => Time.parse((entry/"published").text),
+				:updated_at => Time.parse((entry/"updated").text),
+				:thumbnails => {
+					:small => {
+						:url => (entry/"media:thumbnail[@url$='default.jpg']").attr("url"),
+						:width => 120,
+						:height => 90
+					},
+					:large => {
+						:url => (entry/"media:thumbnail[@url$='hqdefault.jpg]").attr("url"),
+						:width => 480,
+						:height => 360
+					}
+				},
+				:view_count => (entry/"yt:statistics").empty? ? 0 : (entry/"yt:statistics").attr("viewCount"),
+				:favorite_count => (entry/"yt:statistics").empty? ? 0 : (entry/"yt:statistics").attr("favoriteCount"),
+				:comments => comments((entry/"yt:videoid").text),
+				:ratings => ratings((entry/"yt:videoid").text),
+				:status => status,
+				:thumbnails => process_thumbnail_urls(entry)
+			})
+			videos << video
+		end
+		return videos
+	end
+	
+	def count
+		super
+	end
+	
+	def comments(id)
+		xml = super
+		comments = Array.new
+		if (xml/"entry").nitems > 0
+			(xml/"entry").each do |entry|
+				comment = YTComment.new({
+					:title => (entry/"title").text,
+					:content => (entry/"content").text,
+					:author => (entry/"author").search("name").text,
+					:author_uri => (entry/"author").search("uri").text,
+					:video_uri => (entry/"link[@rel='related']").attr("href")
+				})
+				comments << comment
+			end
+		end
+		return comments
+	end
+	
+	def ratings(id)
+		xml = super
+		rating = nil
+		if xml
+			rating = YTRating.new({
+				:num_raters => xml.attr("numRaters").to_i,
+				:max => xml.attr("max").to_i,
+				:min => xml.attr("min").to_i,
+				:average => xml.attr("average").to_f
+			})
+		end
+		return rating
+	end
+	
+	def update_video(id, options)
+		video = find(id)
+		if options[:title]
+			video.title = options[:title]
+		end
+		if options[:description]
+			video.description = options[:description]
+		end
+		if options[:keywords]
+			video.keywords = options[:keywords]
+		end
+		entry = video.to_xml
+		response = update(video.id, entry)
+		if response.status_code == 200
+			return video
+		else
+			return false
+		end
+	end
+	
+	def upload_video(filename, options={})
+		response = upload(filename, options)
+	end
+	
+	def delete_video(id)
+		response = delete(id)
+		if response.status_code == 200
+			return true
+		else
+			return false
+		end
+	end
+	
+	private
+		def process_thumbnail_urls(hpricot)
+			thumbs = (hpricot/"media:thumbnail")
+			OpenStruct.new({:big => thumbs.last.attr("url"), :small => thumbs.first.attr("url")})
+		end
+	
+end

data/lib/yt_client.rb

@@ -0,0 +1,119 @@
+require "uri"
+require "net/http"
+require "gdata"
+require "hpricot"
+require "httparty"
+require "time"
+
+class YTClient
+	attr_accessor :username, :password, :developer_key, :token, :client
+	include HTTParty
+	
+	base_uri "http://gdata.youtube.com/feeds/api"
+	format :plain
+	
+	UPLOAD_URI = "http://uploads.gdata.youtube.com/feeds/api/users/default/uploads"
+	
+	def initialize(username, password, key, options={:refresh=>300})
+		@username = username
+		@password = password
+		@developer_key = key
+		@client = GData::Client::YouTube.new
+		@client.source = "acer_timeline_contest"
+		@client.developer_key = @developer_key
+		@token = @client.clientlogin(@username, @password)
+		@options = options
+	end
+	
+	def all
+		if @all_vids
+			if Time.parse((@all_vids/"updated").text) < (Time.now - @options[:refresh])
+				@all_vids = Hpricot(@client.get(self.class.base_uri + "/users/default/uploads").body)
+			else
+				return @all_vids
+			end
+		else
+			@all_vids = Hpricot(@client.get(self.class.base_uri + "/users/default/uploads").body)
+		end
+	end
+	
+	def count
+		(@all_vids/"entry").nitems
+	end
+	
+	def check_video(id)
+		Hpricot(@client.get(self.class.base_uri + "/videos/#{id}").body)
+	end
+	
+	def ratings(id)
+		response = Hpricot(@client.get(self.class.base_uri + "/videos/#{id}").body)
+		ratings = (response/"gd:rating")
+		if ratings.nitems > 0
+			return ratings
+		else
+			return nil
+		end
+	end
+	
+	def comments(id)
+		Hpricot(@client.get(self.class.base_uri + "/videos/#{id}/comments").body)
+	end
+	
+	def upload(file, options={})
+		upload_uri = URI.parse(UPLOAD_URI)
+		binary_data = read_file(file)
+		request_data = <<-REQDATA
+--bbe873dc
+Content-Type: application/atom+xml; charset=utf-8
+
+<?xml version="1.0"?>
+<entry xmlns="http://www.w3.org/2005/Atom"
+	xmlns:media="http://search.yahoo.com/mrss/"
+	xmlns:yt="http://gdata.youtube.com/schemas/2007">
+	<media:group>
+		<media:title type="plain">#{options[:title]}</media:title>
+		<media:description type="plain">
+			#{options[:description]}
+		</media:description>
+		<media:category scheme="http://gdata.youtube.com/schemas/2007/categories.cat">
+			People
+		</media:category>
+		<media:keywords>#{options[:keywords]}</media:keywords>
+	</media:group>
+</entry>
+--bbe873dc
+Content-Type: #{options[:content_type]}
+Content-Transfer-Encoding: binary
+
+#{binary_data}
+--bbe873dc
+REQDATA
+		http = Net::HTTP.new(upload_uri.host)
+		headers = {
+			'GData-Version' => "2",
+			'X-GData-Key' => "key=#{@developer_key}",
+			'Slug' => File.basename(file),
+			'Authorization' => "GoogleLogin auth=#{@token}",
+			'Content-Type' => 'multipart/related; boundary="bbe873dc"',
+			'Content-Length' => binary_data.length.to_s,
+			'Connection' => 'close'
+		}
+		res = http.post(upload_uri.path, request_data, headers)
+		response = {:code => res.code, :body => Hpricot(res.body)}
+		return response
+	end
+	
+	def update(id, xml)
+		response = @client.put(self.class.base_uri + "/users/default/uploads/#{id}", xml)
+	end
+	
+	def delete(id)
+		response = @client.delete(self.class.base_uri + "/users/default/uploads/#{id}")
+	end
+	
+	private
+	def read_file(file)
+		contents = File.open(file, "r") {|io| io.read }
+		return contents
+	end
+end

data/lib/yt_comment.rb

@@ -0,0 +1,13 @@
+class YTComment
+	
+	attr_accessor :title, :content, :author, :author_uri, :video_uri
+	
+	def initialize(data)
+		@title = data[:title]
+		@content = data[:content]
+		@author = data[:author]
+		@author_uri = data[:author_uri]
+		@video_uri = data[:video_uri]
+	end
+	
+end

data/lib/yt_rating.rb

@@ -0,0 +1,10 @@
+class YTRating
+	attr_accessor :num_raters, :min, :max, :average
+	
+	def initialize(data)
+		@num_raters = data[:num_raters].to_i
+		@min = data[:min].to_i
+		@max = data[:max].to_i
+		@average = data[:average].to_f
+	end
+end

data/lib/yt_video.rb

@@ -0,0 +1,44 @@
+class YTVideo
+
+	attr_reader :id, :duration, :player_uri, :thumbnails, :published_at, :updated_at, :ratings_uri, :comments_uri, :view_count, :favorite_count, :comment_count, :ratings, :comments, :status
+	attr_accessor :title, :description, :keywords
+	
+	def initialize(data)
+		@id = data[:id]
+		@title = data[:title]
+		@description = data[:description]
+		@keywords = data[:keywords]
+		@duration = data[:duration]
+		@player_uri = data[:player_uri]
+		@ratings_uri = data[:ratings_uri]
+		@comments_uri = data[:comments_uri]
+		@published_at = data[:published_at]
+		@updated_at = data[:updated_at]
+		@thumbnails = data[:thumbnails]
+		@view_count = data[:view_count]
+		@favorite_count = data[:favorite_count]
+		@comment_count = data[:comment_count]
+		@ratings = data[:ratings]
+		@comments = data[:comments]
+		@status = data[:status]
+		@thumbnails = data[:thumbnails]
+	end
+	
+	def to_xml
+		data = <<-XMLSTOP
+<?xml version="1.0"?>
+<entry xmlns="http://www.w3.org/2005/Atom"
+	xmlns:media="http://search.yahoo.com/mrss/"
+	xmlns:yt="http://gdata.youtube.com/schemas/2007">
+	<media:group>
+		<media:title type="plain">#{@title}</media:title>
+		<media:description type="plain">#{@description}</media:description>
+		<media:category scheme="http://gdata.youtube.com/schemas/2007/categories.cat">Tech</media:category>
+		<media:keywords>#{@keywords}</media:keywords>
+	</media:group>
+</entry>
+XMLSTOP
+		return data
+	end
+	
+end

data/test/ruby_tube_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+class RubyTubeTest < Test::Unit::TestCase
+  context "a RubyTube instance" do
+		setup do
+			@yt = RubyTube.new
+		end
+		
+		should "contain an instance of GData::Client::YouTube" do
+			assert @yt.client.is_a?(GData::Client::YouTube)
+		end
+		
+		should "get a ClientLogin token from YouTube" do
+			assert @yt.token
+		end
+	end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'ruby_tube'
+
+class Test::Unit::TestCase
+end

data/test/yt_client_test.rb

@@ -0,0 +1,33 @@
+require "test_helper"
+
+
+class YTClientTest < Test::Unit::TestCase
+	context "A YTClient instance" do
+		setup do
+			@yt = YTClient.new("frcmike", "k2130k", RubyTube::DEV_KEY)
+		end
+		
+		should "retrieve a ClientLogin token on instantiation" do
+			assert not_nil(@yt.token)
+		end
+		
+		should "return a list of uploaded files" do
+			assert not_nil(@yt.all)
+		end
+		
+		should "return Fixnum when #count is called" do
+			assert @yt.count.is_a?(Fixnum)
+		end
+		
+		# TODO: write upload tests w/o having to repeat the upload process for each test
+	end
+	
+	private
+	def not_nil(item)
+		!item.nil?
+	end
+	
+	def not_empty(item)
+		!item.empty?
+	end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+name: mikedamage-ruby_tube
+version: !ruby/object:Gem::Version 
+  version: 0.2.1
+platform: ruby
+authors: 
+- Mike Green
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-13 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: gdata
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: httparty
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.4.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.8.1
+    version: 
+description: 
+email: mike.is.green@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/ruby_tube.rb
+- lib/yt_client.rb
+- lib/yt_comment.rb
+- lib/yt_rating.rb
+- lib/yt_video.rb
+- test/josh_walking.mp4
+- test/ruby_tube_test.rb
+- test/test_helper.rb
+- test/yt_client_test.rb
+has_rdoc: false
+homepage: http://github.com/mikedamage/ruby_tube
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: Custom Ruby library for working with YouTube videos, for the Acer Timeline contest project
+test_files: 
+- test/ruby_tube_test.rb
+- test/test_helper.rb
+- test/yt_client_test.rb