gdata 0.0.1

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
+      
+      DEFAULT_OPTIONS = {
+        :auth_url => 'https://www.google.com/accounts/ClientLogin',
+        :account_type => 'HOSTED_OR_GOOGLE' }
+      
+      # 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 = DEFAULT_OPTIONS.merge(options)
+        options.each do |key, value|
+          self.send("#{key}=", value)
+        end
+      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)
+        source = CGI.escape(source)
+        password = CGI.escape(password)
+        username = CGI.escape(username)
+        body = "accountType=#{@account_type}&Email=#{username}" +
+               "&Passwd=#{password}&service=#{@service}&source=#{source}"
+        if login_token and login_captcha
+          body += "&logintoken=#{login_token}&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, "#{error} : #{url}"
+        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 RuntimeError, "Cannot sign request without credentials"
+        end
+        
+        request.headers['Authorization'] = "GoogleLogin auth=#{@token}" 
+      end
+    end
+  end
+end

data/lib/gdata/client.rb

@@ -0,0 +1,49 @@
+# 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/gdata'
+require 'gdata/client/youtube'
+  
+module GData
+  module Client
+    class AuthorizationError < RuntimeError
+    end
+    
+    class BadRequestError < RuntimeError
+    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 < RuntimeError
+    end
+    
+    class UnknownError < RuntimeError
+    end
+    
+    class VersionConflictError < RuntimeError
+    end  
+    
+  end
+end

data/lib/gdata/client/gdata.rb

@@ -0,0 +1,165 @@
+# 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 "rexml/document"
+
+module GData
+  module Client
+    
+    # A client object used to interact with different Google Data APIs.
+    class Base
+      
+      DEFAULT_OPTIONS = {
+        :auth_handler => nil,
+        :http_service => GData::HTTP::DefaultService,
+        :version => "2",
+        :clientlogin_url => nil,
+        :clientlogin_service => nil,
+        :authsub_scope => nil,
+        :headers => {},
+        :source => 'AnonymousApp' }
+    
+      # A subclass of GData::Auth that handles authentication signing.
+      attr_accessor :auth_handler
+      # A subclass of GData::HTTP that handles making HTTP requests.
+      attr_accessor :http_service
+      # Headers to include in every request.
+      attr_accessor :headers
+      # The API version being used.
+      attr_accessor :version
+      # The default URL for ClientLogin.
+      attr_accessor :clientlogin_url
+      # A default service name for ClientLogin (overriden by subclasses).
+      attr_accessor :clientlogin_service
+      # The broadest AuthSub scope for working with an API.
+      # This is overriden by the service-specific subclasses.
+      attr_accessor :authsub_scope
+      # A short string identifying the current application.
+      attr_accessor :source
+      
+      def initialize(options = {})
+        options = DEFAULT_OPTIONS.merge(options)
+        options.each do |key, value|
+          self.send("#{key}=", value)
+        end
+      end
+      
+      # Sends an HTTP request and parses the result with REXML.
+      def make_request(method, url, body = '')
+        headers = self.prepare_headers
+        request = GData::HTTP::Request.new(url, :headers => headers, 
+          :method => method, :body => body)
+        
+        if @auth_handler and @auth_handler.respond_to?(:sign_request!)
+          @auth_handler.sign_request!(request)
+        end
+
+        service = http_service.new
+        response = service.make_request(request)
+        
+        case response.status_code  
+        when 200, 201
+          #Do nothing, it's a success.
+        when 401, 403
+          raise AuthorizationError, response.body
+        when 400
+          raise BadRequestError, response.body
+        when 409
+          raise VersionConflictError, response.body
+        when 500
+          raise ServerError, response.body
+        else
+          raise UnknownError, response.status_code + ' ' + response.body
+        end
+        
+        if response.body
+          begin
+            document = REXML::Document.new(response.body).root
+            if document.nil?
+              return response.body
+            else
+              return document
+            end
+          rescue
+            return response.body
+          end
+        end
+      end
+      
+      # Performs an HTTP GET against the API.
+      def get(url)
+        return self.make_request(:get, url)
+      end
+      
+      # Performs an HTTP PUT against the API.
+      def put(url, body)
+        return self.make_request(:put, url, body)
+      end
+      
+      # Performs an HTTP POST against the API.
+      def post(url, body)
+        return self.make_request(:post, url, body)
+      end
+      
+      # Performs an HTTP DELETE against the API.
+      def delete(url)
+        return self.make_request(:delete, url)
+      end
+      
+      # Constructs some necessary headers for every request.
+      def prepare_headers
+        headers = @headers
+        headers['GData-Version'] = @version
+        headers['User-Agent'] = GData::Auth::SOURCE_LIB_STRING + @source
+        headers['Content-Type'] = 'application/atom+xml'
+        return headers
+      end
+      
+      # Performs ClientLogin for the service.
+      def clientlogin(username, password, captcha_token = nil, captcha_answer = nil, service = nil)
+        if service.nil?
+          service = @clientlogin_service
+        end
+        @auth_handler = GData::Auth::ClientLogin.new(service)
+        if @clientlogin_url
+          @auth_handler.auth_url = @clientlogin_url
+        end
+        source = GData::Auth::SOURCE_LIB_STRING + @source
+        @auth_handler.get_token(username, password, source, captcha_token, captcha_answer)
+      end
+      
+      def authsub_url(next_url, secure = false, session = true, domain = nil,
+        scope = nil)
+        if scope.nil?
+          scope = @authsub_scope
+        end
+        GData::Auth::AuthSub.get_url(next_url, scope, secure, session, domain)
+      end
+      
+      # Sets an AuthSub token for the service.
+      def authsub_token=(token)
+        @auth_handler = GData::Auth::AuthSub.new(token)
+      end
+      
+      # Sets a private key to use with AuthSub requests.
+      def authsub_private_key=(key)
+        if @auth_handler.class == GData::Auth::AuthSub
+          @auth_handler.private_key = key
+        else
+          raise RuntimeError, "An AuthSub token must be set first."
+        end
+      end
+    end
+  end
+end

data/lib/gdata/client/youtube.rb

@@ -0,0 +1,49 @@
+# 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.
+
+module GData
+  module Client
+    
+    # Client class to wrap working with the YouTube API. Sets some 
+    # YouTube-specific options.
+    class YouTube < Base
+      
+      DEFAULT_OPTIONS = {
+        :version => '2',
+        :clientlogin_url => 'https://www.google.com/youtube/accounts/ClientLogin',
+        :clientlogin_service => 'youtube',
+        :authsub_scope => 'http://gdata.youtube.com' }
+      
+      # The YouTube developer key being used.
+      attr_accessor :developer_key
+      # The YouTube ClientID being used.
+      attr_accessor :client_id
+      
+      def initialize(options = {})
+        options = DEFAULT_OPTIONS.merge(options)
+        super(options)
+      end
+      
+      def prepare_headers
+        if @client_id
+          @headers['X-GData-Client'] = @client_id
+        end
+        if @developer_key
+          @headers['X-GData-Key'] = "key=#{@developer_key}"
+        end
+        super
+      end
+    end
+  end
+end

data/lib/gdata/http.rb

@@ -0,0 +1,17 @@
+# 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/http/default_service'
+require 'gdata/http/request'
+require 'gdata/http/response'

data/lib/gdata/http/default_service.rb

@@ -0,0 +1,64 @@
+# 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 'net/http'
+require 'net/https'
+require 'uri'
+
+module GData
+  module HTTP
+  
+    # This is the default implementation of the HTTP layer that uses
+    # Net::HTTP. You could roll your own if you have different requirements
+    # or cannot use Net::HTTP for some reason.
+    class DefaultService
+    
+      # Take a GData::HTTP::Request, execute the request, and return a
+      # GData::HTTP::Response object.
+      def make_request(request)
+        url = URI.parse(request.url)
+        http = Net::HTTP.new(url.host, url.port)
+        http.use_ssl = (url.scheme == 'https')
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        
+        case request.method
+        when :get
+          req = Net::HTTP::Get.new(url.request_uri)
+        when :put
+          req = Net::HTTP::Put.new(url.request_uri)
+          request.calculate_length!
+        when :post
+          req = Net::HTTP::Post.new(url.request_uri)
+          request.calculate_length!
+        when :delete
+          req = Net::HTTP::Delete.new(url.request_uri)
+        else
+          raise ArgumentError, "Unsupported HTTP method specified."
+        end
+        
+        req.body = request.body
+        request.headers.each do |key, value|
+          req[key] = value
+        end
+        res = http.request(req)
+        
+        response = Response.new
+        response.body = res.body
+        response.headers = res.header.to_hash
+        response.status_code = res.code.to_i
+        return response
+      end
+    end
+  end
+end