yt_data_api 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.DS_Store

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in yt_data_api.gemspec
+gemspec

data/README.markdown

@@ -0,0 +1,6 @@
+#Yt_Data_Api
+
+Yt_Data_Api adds functionality to access YouTube Data API.
+
+# TODO
+Add more descriptions...

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/lib/yt_data_api/version.rb

@@ -0,0 +1,3 @@
+module YtDataApi
+  VERSION = "0.0.1"
+end

data/lib/yt_data_api.rb

@@ -0,0 +1,205 @@
+require "yt_data_api/version"
+require 'net/https'
+require 'open-uri'
+require 'rss'
+require 'xml'
+
+module YtDataApi
+  class YtDataApiClient
+    def initialize(user_id, user_pswd, dev_key)
+      self.client_login(user_id, user_pswd, dev_key)
+    end
+
+    def client_login(user_id, user_pswd, dev_key)
+      http = Net::HTTP.new("www.google.com", 443)
+      http.use_ssl = true
+      path = "/accounts/ClientLogin"
+
+      data = "Email=#{user_id}&Passwd=#{user_pswd}&service=youtube&source=Test"
+      headers = {"Content-Type" => "application/x-www-form-urlencoded"}
+
+      response, data = http.post(path, data, headers)
+
+      if(response.code != "200")
+        raise "Error while authenticating YouTube user - #{response.code}"
+      end
+
+      @client_user_id = user_id
+      @client_auth_key = data[/Auth=(.*)/, 1]
+      @dev_auth_key = "key=" + dev_key
+    end
+
+    def get_video_id(search_query)
+      query_uri = URI.parse("http://gdata.youtube.com/feeds/api/videos?q=#{search_query}&max-results=1")
+      rss_query_result = parse_rss(query_uri)
+
+      rss_query_result.items.each do |item|
+        return item.id.to_s[/<id>http:\/\/(.*\/)(.*)<\/id>/, 2]
+      end
+
+      return nil
+    end
+
+    def get_client_playlist_id(playlist_name)
+      headers = {"Content-Type" => "application/x-www-form-urlencoded", 
+                 "Authorization" => "GoogleLogin auth=#{@client_auth_key}", 
+                 "X-GData-Key" => @dev_auth_key}	
+		
+      uri = URI.parse("http://gdata.youtube.com/feeds/api/users/default/playlists?v=2")
+
+      xml_client_playlists = Net::HTTP.start(uri.host, uri.port){|http|
+        http.get(uri.path, headers)
+      }
+
+      #Parse xml of client's playlists
+      source = XML::Parser.string(xml_client_playlists.body)
+      content = source.parse
+      content.root.namespaces.default_prefix = 'atom'
+
+      entries = content.root.find('atom:entry')
+		
+      #Get playlist id
+      entries.each do |entry|
+        if(entry.find_first('atom:title').content.eql?(playlist_name))
+          feedlink = entry.find_first('gd:feedLink').attributes["href"]
+          return feedlink[/http:\/\/gdata.youtube.com\/feeds\/api\/playlists\/(.+)/, 1]
+        end
+      end
+		
+      return nil
+    end
+
+    def get_client_playlist_entries(playlist_id)
+      headers = {"Content-Type" => "application/x-www-form-urlencoded", 
+                 "Authorization" => "GoogleLogin auth=#{@client_auth_key}", 
+                 "X-GData-Key" => @dev_auth_key}	
+		
+      uri = URI.parse("http://gdata.youtube.com/feeds/api/playlists/#{playlist_id}?v=2")
+
+      xml_client_playlist_videos = Net::HTTP.start(uri.host, uri.port){|http|
+        http.get(uri.path, headers)
+      }
+
+      source = XML::Parser.string(xml_client_playlist_videos.body)
+      content = source.parse
+      content.root.namespaces.default_prefix = 'atom'
+
+      entries = content.root.find('atom:entry')
+
+      playlist_entries = []
+
+      entries.each do |entry|
+        entry_id = entry.find_first('atom:id')
+        playlist_entry = 
+          entry_id.content[/http:\/\/.*\/(.+)/, 1]
+        playlist_entries << playlist_entry
+      end
+		
+      playlist_entries
+
+    end
+
+    def add_video_to_playlist(video_id, playlist_id)
+      headers = {"Content-Type" => "application/atom+xml", 
+                 "Authorization" => "GoogleLogin auth=#{@client_auth_key}", 
+                 "X-GData-Key" => @dev_auth_key,
+                 "GData-Version" => "2"}		
+
+      new_row = "<?xml version='1.0' encoding='UTF-8'?>" + 
+                "<entry xmlns='http://www.w3.org/2005/Atom' " + 
+                "xmlns:yt='http://gdata.youtube.com/schemas/2007'>" +
+                "<id>#{video_id}</id></entry>"
+
+      headers["Content-Length"] = new_row.bytesize.to_s
+
+      uri = URI.parse("http://gdata.youtube.com/feeds/api/playlists/#{playlist_id}")
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      post_response = http.post(uri.path, new_row, headers)
+
+      if(post_response.code != "201")
+        raise "Error while adding #{video_id} to #{playlist_id} - #{post_response.code}"
+      end
+
+      post_response.code
+    end
+
+    def create_playlist(playlist_name)
+      headers = {"Content-Type" => "application/atom+xml", 
+                 "Authorization" => "GoogleLogin auth=#{@client_auth_key}", 
+                 "X-GData-Key" => @dev_auth_key,
+                 "GData-Version" => "2"}
+		
+      new_row = "<?xml version='1.0' encoding='UTF-8'?>" + 
+                "<entry xmlns='http://www.w3.org/2005/Atom' " + 
+                "xmlns:yt='http://gdata.youtube.com/schemas/2007'>" +
+                "<title type='text'>#{playlist_name}</title><summary></summary></entry>"
+
+      headers["Content-Length"] = new_row.bytesize.to_s
+
+      uri = URI.parse("http://gdata.youtube.com/feeds/api/users/default/playlists")
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      post_response = http.post(uri.path, new_row, headers)
+
+      if(post_response.code != "201")
+        raise "Error while creating #{playlist_name} - #{post_response.code}"
+      end
+
+      post_response.code
+    end
+
+    def empty_playlist(playlist_id)
+      headers = {"Content-Type" => "application/atom+xml", 
+                 "Authorization" => "GoogleLogin auth=#{@client_auth_key}", 
+                 "X-GData-Key" => @dev_auth_key,
+                 "GData-Version" => "2"}
+
+      playlist_entries = self.get_client_playlist_entries(playlist_id)
+
+      playlist_entries.each do |playlist_entry|
+        uri = URI.parse("http://gdata.youtube.com/feeds/api/playlists/#{playlist_id}/#{playlist_entry}")
+        http = Net::HTTP.new(uri.host, uri.port)
+
+        delete_response = http.delete(uri.path, headers)
+    
+        if(delete_response.code != "200")
+          raise "#{playlist_entry} not deleted from #{@playlist_id} - #{delete_response.code}"
+        end
+      end
+
+      self.get_client_playlist_entries(playlist_id).empty?
+    end
+
+    def delete_playlist(playlist_id)
+      headers = {"Content-Type" => "application/atom+xml", 
+                 "Authorization" => "GoogleLogin auth=#{@client_auth_key}", 
+                 "X-GData-Key" => @dev_auth_key,
+                 "GData-Version" => "2"}
+
+      uri = URI.parse("http://gdata.youtube.com/feeds/api/users/#{@client_user_id}/playlists/#{playlist_id}")
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      delete_response = http.delete(uri.path, headers)
+    
+      if(delete_response.code != "200")
+        raise "#{playlist_id} not deleted for #{@client_user_id} - #{delete_response.code}"
+      end
+
+      delete_response.code
+    end
+
+    private
+      #Use Ruby RSS Parser to return parseable info from RSS feed
+      def parse_rss(rss_feed)
+        rss_content = ""
+
+        #Get feed information
+        open (rss_feed) do |f|
+          rss_content = f.read
+        end
+
+        RSS::Parser.parse(rss_content, false)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'rspec'
+require 'yt_data_api'

data/spec/yt_data_api_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe "YtDataApi::YtDataApiClient" do
+  it "should create a new instance using ClientLogin authentication" do
+    YtDataApi::YtDataApiClient.new(ENV['YT_USER'], ENV['YT_USER_PSWD'], ENV['YT_DEV_AUTH_KEY'])
+  end
+
+  it "should not create a new instance without credentials for ClientLogin Authentication" do
+    lambda{ YtDataApi::YtDataApiClient.new }.should raise_error ArgumentError
+  end
+
+  it "should not create a new instance without valid credentials for ClientLogin Authentication" do
+    lambda{ YtDataApi::YtDataApiClient.new("trash", "trash", "trash") }.should raise_error
+  end 
+
+  describe "authenticated" do
+    before(:each) do
+      @client = YtDataApi::YtDataApiClient.new(ENV['YT_USER'], ENV['YT_USER_PSWD'], ENV['YT_DEV_AUTH_KEY'])
+      @create_response = @client.create_playlist("test_one")
+      @playlist_id = @client.get_client_playlist_id("test_one")
+    end
+
+    it "should create a client's playlist" do
+      @create_response.should == "201"
+    end
+
+    it "should get a client's playlist id given the playlist's name" do
+     @playlist_id.should_not be nil
+    end
+
+    it "should get a video id given a query string" do
+      query = "vampire-weekend-giving-up-the-gun"
+      video_id = @client.get_video_id(query)
+      video_id.should == "bccKotFwzoY"
+    end
+
+    it "should add a video to a client's playlist" do
+      video_id = "bccKotFwzoY"
+      post_response = @client.add_video_to_playlist(video_id, @playlist_id)
+      post_response.should == "201"
+    end
+
+    it "should remove all videos from a client's playlist" do
+      3.times do
+        @client.add_video_to_playlist("bccKotFwzoY", @playlist_id)
+      end
+     
+      empty_playlist = @client.empty_playlist(@playlist_id)
+      empty_playlist.should == true
+    end
+
+    it "should delete a client's playlist" do
+      delete_response = @client.delete_playlist(@playlist_id)
+      delete_response.should == "200"
+    end
+
+    after(:each) do
+      playlist = @client.get_client_playlist_id("test_one")
+      @client.delete_playlist(@playlist_id) unless playlist.nil?
+    end
+  end
+end

data/yt_data_api.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "yt_data_api/version"
+
+Gem::Specification.new do |s|
+  s.name        = "yt_data_api"
+  s.version     = YtDataApi::VERSION
+  s.authors     = ["Ali Ibrahim"]
+  s.email       = ["aibrahim2k2@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Adds functionality to access YouTube Data API}
+  s.description = %q{Create a new instance of YtDataApi::YtDataApiClient passing 
+                     user credentials (username, password) and YouTube developer key
+                     to access YouTube Data API using ClientLogin authentication.}
+
+  s.rubyforge_project = "yt_data_api"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'libxml-ruby', '~>1.1.3'
+
+  s.add_development_dependency 'rspec', '~>2.4.0'
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: yt_data_api
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Ali Ibrahim
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-24 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: libxml-ruby
+  requirement: &70195100472000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *70195100472000
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70195100474040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.4.0
+  type: :development
+  prerelease: false
+  version_requirements: *70195100474040
+description: ! "Create a new instance of YtDataApi::YtDataApiClient passing \n                     user
+  credentials (username, password) and YouTube developer key\n                     to
+  access YouTube Data API using ClientLogin authentication."
+email:
+- aibrahim2k2@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.markdown
+- Rakefile
+- lib/yt_data_api.rb
+- lib/yt_data_api/version.rb
+- spec/spec_helper.rb
+- spec/yt_data_api_spec.rb
+- yt_data_api.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: yt_data_api
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Adds functionality to access YouTube Data API
+test_files:
+- spec/spec_helper.rb
+- spec/yt_data_api_spec.rb