chocolate_rain 0.0.1

data/.gitignore

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

data/Gemfile

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

data/Rakefile

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

data/chocolate_rain.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "chocolate_rain/version"
+
+Gem::Specification.new do |s|
+  s.name        = "chocolate_rain"
+  s.version     = ChocolateRain::VERSION
+  s.authors     = ["Kevin Hopkins"]
+  s.email       = ["kevin@wearefound.com"]
+  s.homepage    = ""
+  s.summary     = %q{YouTube API wrapper for 1.9.2 compatible with Rails >= 3.1}
+  s.description = %q{YouTube API wrapper for 1.9.2 compatible with Rails >= 3.1}
+
+  s.rubyforge_project = "chocolate_rain"
+
+  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"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+  s.required_rubygems_version = ">= 1.8.6"
+
+end

data/generators/youtube_model/USAGE

@@ -0,0 +1,3 @@
+./script/generate youtube_model MODELNAME
+
+Generates an ActiveResource model that is ready for interact with YouTube API

data/generators/youtube_model/templates/config.yml

@@ -0,0 +1,6 @@
+developer_tag: your_developer_tag
+auth_sub:
+  secure: 0
+  session: 0
+  developer_key: YourAPIKeyGoesHere
+  client_key: And-Here-Goes-Your-Client-Key

data/generators/youtube_model/templates/model.rb

@@ -0,0 +1,17 @@
+class <%= class_name %> < YouTubeModel::Base #inherits from ActiveResource::Base
+  self.default_youtube_options= {:itemPerPage => 10}
+
+  schema do
+    attribute :title, :string
+    attribute :description, :string
+    attribute :keywords, :string
+    attribute :category, :string
+    attribute :file, :string
+    attribute :token, :string
+  end
+
+  validates_presence_of :title
+  validates_presence_of :token #needed on remote crud operation
+  validates_presence_of :file, :if => Proc.new{|<%=singular_name%>| <%=singular_name%>.new? }
+
+end

data/generators/youtube_model/templates/unit_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class <%= class_name %>Test < Test::Unit::TestCase
+  def test_this_plugin
+    # needs some tests...
+  end
+end

data/generators/youtube_model/youtube_model_generator.rb

@@ -0,0 +1,15 @@
+class YoutubeModelGenerator < Rails::Generators::NamedBase
+
+  desc "Generate youtube_model files, Usage: rails g youtube_model ModelName"
+
+  source_root File.expand_path('../templates', __FILE__)
+
+  check_class_collision
+
+  def manifest
+    template 'model.rb', File.join('app/models', class_path, "#{file_name}.rb")
+    template 'unit_test.rb', File.join('test/unit', class_path, "#{file_name}_test.rb")
+    template 'config.yml', File.join('config', "#{file_name}_config.yml")
+  end
+  
+end

data/lib/chocolate_rain.rb

@@ -0,0 +1,5 @@
+require "chocolate_rain/version"
+
+module ChocolateRain
+  # Your code goes here...
+end

data/lib/chocolate_rain/version.rb

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

data/lib/gdata/auth/authsub.rb

@@ -0,0 +1,161 @@
+# Copyright (C) 2008 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'cgi'
+require 'openssl'
+require 'base64'
+
+module GData
+  module Auth
+    
+    # This class implements AuthSub signatures for Data API requests.
+    # It can be used with a GData::Client::GData object.
+    class AuthSub
+      
+      # The URL of AuthSubRequest.
+      REQUEST_HANDLER = 'https://www.google.com/accounts/AuthSubRequest'
+      # The URL of AuthSubSessionToken.
+      SESSION_HANDLER = 'https://www.google.com/accounts/AuthSubSessionToken'
+      # The URL of AuthSubRevokeToken.
+      REVOKE_HANDLER = 'https://www.google.com/accounts/AuthSubRevokeToken'
+      # The URL of AuthSubInfo.
+      INFO_HANDLER =  'https://www.google.com/accounts/AuthSubTokenInfo'
+      # 2 ** 64, the largest 64 bit unsigned integer
+      BIG_INT_MAX = 18446744073709551616
+      
+      # AuthSub access token.
+      attr_accessor :token
+      # Private RSA key used to sign secure requests.
+      attr_reader :private_key
+      
+      # Initialize the class with a new token. Optionally pass a private
+      # key or custom URLs.
+      def initialize(token, options = {})
+        if token.nil?
+          raise ArgumentError, "Token cannot be nil."
+        elsif token.class != String
+          raise ArgumentError, "Token must be a String."
+        end
+        
+        @token = token
+        
+        options.each do |key, value|
+          self.send("#{key}=", value)
+        end
+      end
+      
+      # Set the private key to use with this AuthSub token.
+      # The key can be an OpenSSL::PKey::RSA object, a string containing a
+      # private key in PEM format, or a string specifying a path to a PEM
+      # file that contains the private key.
+      def private_key=(key)
+        begin
+          if key.nil? or key.class == OpenSSL::PKey::RSA
+            @private_key = key
+          elsif File.exists?(key)
+            key_from_file = File.read(key)
+            @private_key = OpenSSL::PKey::RSA.new(key_from_file)
+          else
+            @private_key = OpenSSL::PKey::RSA.new(key)
+          end
+        rescue
+          raise ArgumentError, "Not a valid private key."
+        end
+      end
+      
+      # Sign a GData::Http::Request object with a valid AuthSub Authorization
+      # header.
+      def sign_request!(request)
+        header = "AuthSub token=\"#{@token}\""
+        
+        if @private_key
+          time = Time.now.to_i
+          nonce = OpenSSL::BN.rand_range(BIG_INT_MAX)
+          method = request.method.to_s.upcase
+          data = "#{method} #{request.url} #{time} #{nonce}"
+          sig = @private_key.sign(OpenSSL::Digest::SHA1.new, data)
+          sig = Base64.encode64(sig).gsub(/\n/, '')
+          header = "#{header} sigalg=\"rsa-sha1\" data=\"#{data}\""
+          header = "#{header} sig=\"#{sig}\""
+        end
+        
+        request.headers['Authorization'] = header
+      end
+      
+      # Upgrade the current token into a session token.
+      def upgrade
+        request = GData::HTTP::Request.new(SESSION_HANDLER)
+        sign_request!(request)
+        service = GData::HTTP::DefaultService.new
+        response = service.make_request(request)
+        if response.status_code != 200
+          raise GData::Client::AuthorizationError.new(response)
+        end
+        
+        @token = response.body[/Token=(.*)/,1]
+        return @token
+        
+      end
+      
+      # Return some information about the current token. If the current token
+      # is a one-time use token, this operation will use it up!
+      def info
+        request = GData::HTTP::Request.new(INFO_HANDLER)
+        sign_request!(request)
+        service = GData::HTTP::DefaultService.new
+        response = service.make_request(request)
+        if response.status_code != 200
+          raise GData::Client::AuthorizationError.new(response)
+        end
+        
+        result = {}
+        result[:target] = response.body[/Target=(.*)/,1]
+        result[:scope] = response.body[/Scope=(.*)/,1]
+        result[:secure] = response.body[/Secure=(.*)/,1]
+        return result
+       
+      end
+      
+      # Revoke the token.
+      def revoke
+        request = GData::HTTP::Request.new(REVOKE_HANDLER)
+        sign_request!(request)
+        service = GData::HTTP::DefaultService.new
+        response = service.make_request(request)
+        if response.status_code != 200
+          raise GData::Client::AuthorizationError.new(response)
+        end
+
+      end
+      
+      # Return the proper URL for an AuthSub approval page with the requested
+      # scope. next_url should be a URL that points back to your code that
+      # will receive the token. domain is optionally a Google Apps domain.
+      def self.get_url(next_url, scope, secure = false, session = true, 
+          domain = nil)
+        next_url = CGI.escape(next_url)
+        scope = CGI.escape(scope)
+        secure = secure ? 1 : 0
+        session = session ? 1 : 0
+        body = "next=#{next_url}&scope=#{scope}&session=#{session}" +
+               "&secure=#{secure}"
+        if domain
+          domain = CGI.escape(domain)
+          body = "#{body}&hd=#{domain}"
+        end
+        return "#{REQUEST_HANDLER}?#{body}"
+      end
+    end
+  end
+end

data/lib/gdata/auth/clientlogin.rb

@@ -0,0 +1,102 @@
+# Copyright (C) 2008 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'cgi'
+
+module GData
+  module Auth
+    
+    # This class implements ClientLogin signatures for Data API requests.
+    # It can be used with a GData::Client::GData object.
+    class ClientLogin
+      
+      # The ClientLogin authentication handler
+      attr_accessor :auth_url
+      # One of 'HOSTED_OR_GOOGLE', 'GOOGLE', or 'HOSTED'. 
+      # See documentation here: 
+      # http://code.google.com/apis/accounts/docs/AuthForInstalledApps.html
+      attr_accessor :account_type
+      # The access token
+      attr_accessor :token
+      # The service name for the API you are working with
+      attr_accessor :service
+      
+      # Initialize the class with the service name of an API that you wish
+      # to request a token for.
+      def initialize(service, options = {})
+        if service.nil?
+          raise ArgumentError, "Service name cannot be nil"
+        end
+        
+        @service = service
+        
+        options.each do |key, value|
+          self.send("#{key}=", value)
+        end
+        
+        @auth_url ||= 'https://www.google.com/accounts/ClientLogin'
+        @account_type ||= 'HOSTED_OR_GOOGLE'
+      end
+      
+      # Retrieves a token for the given username and password.
+      # source identifies your application.
+      # login_token and login_captcha are used only if you are responding
+      # to a previously issued CAPTCHA challenge.
+      def get_token(username, password, source, login_token = nil, 
+          login_captcha = nil)
+        body = Hash.new
+        body['accountType'] = @account_type
+        body['Email'] = username
+        body['Passwd'] = password
+        body['service'] = @service
+        body['source'] = source
+        if login_token and login_captcha
+          body['logintoken'] = login_token
+          body['logincaptcha'] = login_captcha
+        end
+        
+        request = GData::HTTP::Request.new(@auth_url, :body => body, 
+          :method => :post)
+        service = GData::HTTP::DefaultService.new
+        response = service.make_request(request)
+        if response.status_code != 200
+          url = response.body[/Url=(.*)/,1]
+          error = response.body[/Error=(.*)/,1]
+          
+          if error == "CaptchaRequired"
+            captcha_token = response.body[/CaptchaToken=(.*)/,1]
+            captcha_url = response.body[/CaptchaUrl=(.*)/,1]
+            raise GData::Client::CaptchaError.new(captcha_token, captcha_url), 
+              "#{error} : #{url}"
+          end
+          
+          raise GData::Client::AuthorizationError.new(response)
+        end
+        
+        @token = response.body[/Auth=(.*)/,1]
+        return @token
+      end
+      
+      # Creates an appropriate Authorization header on a GData::HTTP::Request
+      # object.
+      def sign_request!(request)
+        if @token == nil
+          raise GData::Client::Error, "Cannot sign request without credentials"
+        end
+        
+        request.headers['Authorization'] = "GoogleLogin auth=#{@token}" 
+      end
+    end
+  end
+end

data/lib/gdata/client.rb

@@ -0,0 +1,84 @@
+# Copyright (C) 2008 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'gdata/client/base'
+require 'gdata/client/apps'
+require 'gdata/client/blogger'
+require 'gdata/client/booksearch'
+require 'gdata/client/calendar'
+require 'gdata/client/contacts'
+require 'gdata/client/doclist'
+require 'gdata/client/finance'
+require 'gdata/client/gbase'
+require 'gdata/client/gmail'
+require 'gdata/client/health'
+require 'gdata/client/notebook'
+require 'gdata/client/photos'
+require 'gdata/client/spreadsheets'
+require 'gdata/client/webmaster_tools'
+require 'gdata/client/youtube'
+  
+module GData
+  module Client
+
+    # Base class for GData::Client errors
+    class Error < RuntimeError
+    end
+
+    # Base class for errors raised due to requests
+    class RequestError < Error
+
+      # The Net::HTTPResponse that caused this error.
+      attr_accessor :response
+
+      # Creates a new RequestError from Net::HTTPResponse +response+ with a
+      # message containing the error code and response body.
+      def initialize(response)
+        @response = response
+
+        super "request error #{response.status_code}: #{response.body}"
+      end
+
+    end
+
+    class AuthorizationError < RequestError
+    end
+    
+    class BadRequestError < RequestError
+    end
+    
+    # An error caused by ClientLogin issuing a CAPTCHA error.
+    class CaptchaError < RuntimeError
+      # The token identifying the CAPTCHA
+      attr_reader :token
+      # The URL to the CAPTCHA image
+      attr_reader :url
+      
+      def initialize(token, url)
+        @token = token
+        @url = url
+      end
+    end
+    
+    class ServerError < RequestError
+    end
+    
+    class UnknownError < RequestError
+    end
+    
+    class VersionConflictError < RequestError
+    end  
+    
+  end
+end