cs210-gdata4ruby 0.1.5 → 0.2.0

data/CHANGELOG

@@ -1,4 +1,7 @@
+<<<<<<< HEAD
 #=CHANGELOG
+#==version 0.1.6
+#* Save the 'S'-cookie and send it with future requests to avoid '302 Redirect' responses
 #==version 0.1.5
 #* Changed license to LGPLv3
 #==version 0.1.4
@@ -12,3 +15,22 @@
 #* Added additional common attributes, including content, published, updated and author info
 #==version 0.1.0
 #* Initial Version
+=======
+=CHANGELOG
+==version 0.2.0
+* Implemented OAuth support (using the OAuth gem)
+* This requires minor changes to how the Base & Service classes are called
+==version 0.1.5
+* Changed license to LGPLv3
+==version 0.1.4
+* Bugfix for GeoRSS and GML namespaces
+==version 0.1.3
+* Added support for Geo/GeoRSS namespaces in base gdata object
+* Added support for Ruby 1.9
+==version 0.1.2
+* Added better support for 'default' users in AccessRule
+==version 0.1.1
+* Added additional common attributes, including content, published, updated and author info
+==version 0.1.0
+* Initial Version
+>>>>>>> edave/master

data/README.md

@@ -1,45 +1,71 @@
 #GData4Ruby
 
-##Introduction
+## Introduction
 
-GData4Ruby is a full featured wrapper for the Google Data base API.  GData4Ruby provides the ability
-to authenticate with GData using the ClientLogin method.  The package also includes a base gdata object 
-that can be subclassed to provide basic CRUD functions for all Google API service objects.  Additionally,
-a basic ACL object is included for interacting with ACL feeds and setting access rules.
+GData4Ruby is a full featured wrapper for the Google Data base API.  GData4Ruby provides the ability to authenticate with GData using the ClientLogin method.  The package also includes a base gdata object  that can be subclassed to provide basic CRUD functions for all Google API service objects.  Additionally, a basic ACL object is included for interacting with ACL feeds and setting access rules.
 
-##Author and Contact Information
+## Author and Contact Information
 
-GData4Ruby was created and is maintained by [Mike Reich](mailto:mike@seabourneconsulting.com]) 
-and is licenses under the LGPL v3.  You can find the text of the LGPL 
-here: http://www.gnu.org/licenses/lgpl.html.  Feel free to use and update, but be sure to contribute your
-code back to the project and attribute as required by the license.
+GData4Ruby was created and is maintained by {Mike Reich}[mailto:mike@seabourneconsulting.com]  and is licenses under the LGPL v3.  You can find the text of the LGPL here: http://www.gnu.org/licenses/lgpl.html.  Feel free to use and update, but be sure to contribute your code back to the project and attribute as required by the license.
 
-##Website
+OAuth support was added by [edave](https://github.com/edave/)
 
-[http://cookingandcoding.com/gdata4ruby/](http://cookingandcoding.com/gdata4ruby/)
+### Website
 
-##Description
+http://cookingandcoding.com/gdata4ruby/
 
-GData4Ruby has three major components: the service, the GData object and the AccessRule object.  Each service
-represents a google account, and includes a username (email) and a password.  You can use the GData service
-to authenticate either a google account or a google apps account.
+## Description
+
+GData4Ruby has three major components: the service, the GData object and the AccessRule object.  Each service represents a google account, and includes a username (email) and a password.  You can use the GData service to authenticate either a google account or a google apps account. There are currently two types of services, Service, and OAuthService. 
+
+Service uses Google's older [AuthSub](http://code.google.com/apis/accounts/docs/AuthSub.html) authentication mechanism, which is easier to setup, but requires you always know the username/password. (called Service to maintain backwards compatibility, but don't be confused, the base "Service" class is named Base)
+
+OAuthService uses Google's newest authentication mechanism, [OAuth](http://code.google.com/apis/accounts/docs/OAuth.html), which is an OpenID-esque login system.
+
+See Google's [Getting Started](http://code.google.com/apis/accounts/docs/GettingStarted.html) for more info on which mechanism is best for you. In general, it will likely be easiest to experiment with GData4Ruby using AuthSub and then switch to OAuth for any actual usage in your web app, etc.
 
 The GData object provides a base class for interacting with Google API objects, i.e. Documents, Events, etc.  The GData object contains common attributes present in all Google API objects, and provides interfaces for basic CRUD functions.  This class is meant to be subclassed.
 
 The AccessRule object provides a base class for interacting with Google Access Control Lists.  ACLs provide the main permissions mechanism for most Google API services.
 
-##Examples
+## Examples
 
 Below are some common usage examples.  For more examples, check the documentation.
 
-###Service
+### Service
 
 1. Authenticate
-
     service = Service.new
-    service.authenticate("user@gmail.com", "password", "cl")
+    service.authenticate({:username => "user@gmail.com", :password => "password", :service => "cl"})
 
 2. Authenticate with a specified GData version
+	service = Service.new({:gdata_version => '3.0'})
+	service.authenticate({:username => "user@gmail.com", :password => "password", :service => "cl"})
+	
+### OAuthService
+
+You will need an OAuth Token for authenticating for any given user. If you are using Rails, [OAuth Plugin](https://github.com/pelle/oauth-plugin) makes this fairly easy for users to grant access to your application and generate [OAuth Tokens](http://code.google.com/p/oauth-plugin/wiki/AccessToken).
+
+Once you have a token, authenticating is simple:
+
+	service = OAuthService.new
+	my_oauth_token = OAuth::AccessToken.new() # you will need to generate your own OAuth::Token
+	service.authenticate({:access_token=>my_oauth_token})
+
+	
+
+## Base Options
+
+GData4Ruby supports several options which are passed to any service (Base, Service, OAuthService) upon initialization using a hash
+
+Enable SSL:
+
+	my_generic_service = Service.new({:use_ssl => true})
+
+Enable Debug Logging:
+
+	my_generic_service = Service.new({:debug => true})
+	
+Disable checking whether the objects are publicly accessibly. This can significantly speed up the service, but also leaves you at risk of trying write to Google services which you do not have privileges. In many cases, you can disable this option.
 
-    service = Service.new({:gdata_version => '3.0'})
-    service.authenticate("user@gmail.com", "password", "cl")
+	my_generic_service = Service.new({:check_public => false})

data/lib/gdata4ruby.rb

@@ -1 +1,2 @@
 require "gdata4ruby/service" 
+require "gdata4ruby/oauth_service"

data/lib/gdata4ruby/base.rb

@@ -65,11 +65,12 @@ module GData4Ruby
   #the Service subclass.
 
   class Base
-    AUTH_URL = "https://www.google.com/accounts/ClientLogin"
+    @@auth_url = "https://www.google.com/accounts/ClientLogin"
     @proxy_info = nil
     @auth_token = nil
     @debug = false
     @gdata_version = '2.1'
+    @session_cookie = nil
 
     #Contains the ProxyInfo object for using a proxy server
     attr_accessor :proxy_info
@@ -80,27 +81,82 @@ module GData4Ruby
     #The GData version used by the service
     attr_accessor :gdata_version
 
+    # Will have the service use https instead of http
+    attr_accessor :use_ssl
+
     #Optionally, pass a hash of attributes to populate the class.  If you want to use a GData version
     #other than the default (2.1), pass a key/value pair, i.e. {:gdata_version => '1.0'}      
     def initialize(attributes = {})
-      @gdata_version = attributes[:gdata_version] ? attributes[:gdata_version] : '2.1'
+      attributes.each do |key, value|
+        if self.respond_to?("#{key}=")
+          self.send("#{key}=", value)
+        end
+      end
+      @gdata_version ||= '2.1'
+      @use_ssl ||= false
+      @debug ||= false
     end
     
+    # Provides a mechanism for your service to receive credentials and authenticate
+    def authenticate(options = {})
+      
+    end 
+    
+    # Allows a user to revive the authentication (connection)
+    def reauthenticate(options = {})
+      
+    end
+    
+    # Is the service successfully authenticated and connected to google?
+    def authenticated?
+      return false
+    end
+    
+    def log(string)
+      puts string if self.debug
+    end
+    
+    def create_url(path)
+      return http_protocol + path
+    end
+       
     #Sends a request to the Google Data System.  Accepts a valid Request object, and returns a 
     #HTTPResult class.
     def send_request(request)
       raise ArgumentError 'Request must be a GData4Ruby::Request object' if not request.is_a?Request
-      puts "sending #{request.type} to url = #{request.url.to_s}" if @debug
+      log("sending #{request.type} to url = #{request.url.to_s}")
       do_request(request)
     end
 
     private
 
+    def set_protocol!(request)
+      uri = request.url
+      if uri.scheme != protocol
+        request.url = URI.parse(uri.to_s.sub(uri.scheme, protocol))
+        # values = uri.select(*uri.component)
+        #         keys = uri.component
+        #         components_hash = {}
+        #         # Build a hash where the keys are from keys[] and values are from values[]
+        #         keys.zip(values) {|a,b| components_hash[a] = b }
+        #         components_hash[:scheme] = protocol
+        #         request.url = case protocol
+        #         when 'https'
+        #           URI::HTTPS.build(components_hash)
+        #         when 'http'
+        #           URI::HTTP.build(components_hash)
+        #         end
+        end
+    end
+
     def do_request(request)
       ret = nil
       add_auth_header(request)
+      # Add the session cookie if available
+      request.headers.merge!({'Cookie' => @session_cookie}) if @session_cookie
+      set_protocol!(request)
       http = get_http_object(request.url)
-      puts "Sending request\nHeader: #{request.headers.inspect.to_s}\nContent: #{request.content.to_s}\n" if @debug
+      log("Sending request\nHeader: #{request.headers.inspect.to_s}\nContent: #{request.content.to_s}\n")
       http.start do |ht|
         ret = case request.type
           when :get
@@ -113,19 +169,31 @@ module GData4Ruby
             ht.delete(request.url.to_s, request.headers)
         end
       end
-      
+
+      if @debug
+        puts "Response code: #{ret.code}"
+        puts "Headers: \n"
+        ret.each { |h, v| puts "#{h}:#{v}" }
+        puts "Body: \n" + ret.read_body
+      end
+
+      # Save the session cookie if set
+      ret.get_fields('set-cookie').to_a.each do |header|
+        cookie = header.split(';').first
+        @session_cookie = cookie if cookie =~ /^S=.+/
+      end
+
       while ret.is_a?(Net::HTTPRedirection)
-        puts "Redirect received, resending request" if @debug
+        log("Redirect received, resending request")
         request.parameters = nil
         request.url = ret['location']
-        puts "sending #{request.type} to url = #{request.url.to_s}" if @debug
+        log("sending #{request.type} to url = #{request.url.to_s}")
         ret = do_request(request)
       end
       if not ret.is_a?(Net::HTTPSuccess)
-        puts "invalid response received: "+ret.code if @debug
+        log("invalid response received: "+ret.code)
         raise HTTPRequestFailed, ret.body
       end
-      puts "20x response received\nResponse: \n"+ret.read_body if @debug
       return ret
     end
 
@@ -137,7 +205,7 @@ module GData4Ruby
 	    end
       if location.scheme == 'https'
         #fixed http/http misnaming via JohnMetta
-        puts "SSL True" if @debug
+        log("SSL True")
         http.use_ssl = true
         http.verify_mode = OpenSSL::SSL::VERIFY_NONE
       end
@@ -154,5 +222,18 @@ module GData4Ruby
         end
       end
     end
+    
+    protected
+      def protocol
+        ssl_suffix = ""
+        ssl_suffix = "s" if use_ssl
+        return "http#{ssl_suffix}"
+      end
+      def http_protocol
+        ssl_suffix = ""
+        ssl_suffix = "s" if use_ssl
+        return "http#{ssl_suffix}://"
+      end
+    
   end
 end

data/lib/gdata4ruby/gdata_object.rb

@@ -73,6 +73,9 @@ module GData4Ruby
     #The kind (type) of the object
     attr_reader :kind
     
+    #Used for debugging
+    attr_accessor :debug
+    
     #Indicates whether the object exists on the Google servers, i.e. has been created/saved.
     def exists?
       return @exists
@@ -89,7 +92,9 @@ module GData4Ruby
       @categories = @feed_links = []
       @include_etag = true
       attributes.each do |key, value|
-        self.send("#{key}=", value)
+        if self.respond_to?("#{key}=")
+          self.send("#{key}=", value)
+        end
       end
     end
     
@@ -104,14 +109,16 @@ module GData4Ruby
         @etag = xml.root.attributes['etag'] if xml.root.attributes['etag']
         case ele.name
           when "id"
-            puts 'setting id' if service.debug
             @feed_uri = ele.text
+            log("ID: #{@feed_uri}")
           when 'content'
             @content_uri = ele.attributes['src'] if ele.attributes['src']
+            log("Content URI: #{@content_uri}")
           when 'resourceId'
             @id = ele.text
           when 'title'
             @title = ele.text
+            log("Title: #{@title}")
           when 'category'
             @categories << {:label => ele.attributes['label'], 
                             :scheme => ele.attributes['scheme'],
@@ -160,6 +167,11 @@ module GData4Ruby
       return true
     end
     
+    
+    def log(string)
+      puts string if debug
+    end
+    
     #Creates the object.  This must be overridden in a subclass, as the feed url for creating new
     #objects/entries is service dependent.  In other words, each google service uses a different 
     #URI for saving new objects.
@@ -194,4 +206,4 @@ module GData4Ruby
       xml.to_s
     end
   end
-end
+end

data/lib/gdata4ruby/oauth_service.rb

@@ -0,0 +1,95 @@
+# Author:: David Pitman (ui-design@vestaldesign.com )
+# Copyright:: Copyright (C) 2010 David Pitman
+# License:: LGPL v2.1
+#--
+# Licensed under the Lesser General Public License (GPL), Version 2.1 (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.gnu.org/licenses/lgpl-2.1.txt
+#
+# 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.
+#
+# Feel free to use and update, but be sure to contribute your
+# code back to the project and attribute as required by the license.
+#++
+require 'gdata4ruby/base' 
+
+module GData4Ruby
+  #The service class is the main handler for all direct interactions with the 
+  #Google Data API.
+  
+  class OAuthService < Base
+    #Convenience attribute contains the currently OAuth access token
+    attr_reader :access_token
+    
+    #Accepts an optional attributes hash for initialization values, most likely :gdata_version
+    def initialize(attributes = {})
+      super(attributes)
+      attributes.each do |key, value|
+        if self.respond_to?("#{key}=")
+          self.send("#{key}=", value)
+        end
+      end    
+    end
+    
+    # The method is a generic hash to allow subclasses to easily receive args for their own type of authentication
+    # In this case, we're using an OAuth AccessToken - http://oauth.rubyforge.org/rdoc/classes/OAuth/AccessToken.html
+    def authenticate(options = {})
+      @access_token = options[:access_token]
+    end
+    
+    def reauthenticate(options = {})
+      @access_token ||= options[:access_token]
+    end
+    
+    
+    def authenticated?
+      return (@access_token != nil)
+    end
+    
+    private
+    
+    def do_request(request)
+      log("Sending request\nHeader: #{request.headers.inspect.to_s}\nContent: #{request.content.to_s}\n")
+      set_protocol!(request)
+      ret = case request.type
+          when :get
+            @access_token.get(request.url.to_s, {}, request.headers)
+          when :post
+            @access_token.post(request.url.to_s, request.content, request.headers)
+          when :put
+            @access_token.put(request.url.to_s, request.content, request.headers)
+          when :delete
+            @access_token.delete(request.url.to_s, {}, request.headers)
+      end
+      
+      while ret.is_a?(Net::HTTPRedirection)
+        log("Redirect received, resending request")
+        request.parameters = nil
+        request.url = ret['location']
+        log("sending #{request.type} to url = #{request.url.to_s}")
+        ret = do_request(request)
+      end
+      if not ret.is_a?(Net::HTTPSuccess)
+        log("invalid response received: "+ret.code)
+        raise HTTPRequestFailed, ret.body
+      end
+      log("20x response received\nResponse: \n"+ret.read_body)
+      return ret
+    end
+
+    # Not used in OAuth implementation...
+    def get_http_object(location)
+      return nil
+    end
+    
+    # Not used in OAuth implementation...
+    def add_auth_header(request)
+      return nil
+    end
+  
+  end
+end

data/lib/gdata4ruby/service.rb

@@ -32,17 +32,24 @@ module GData4Ruby
     def initialize(attributes = {})
       super(attributes)
       attributes.each do |key, value|
-        self.send("#{key}=", value)
+        if self.respond_to?("#{key}=")
+          self.send("#{key}=", value)
+        end
       end    
     end
     
     # The authenticate method passes the username and password to google servers.  
     # If authentication succeeds, returns true, otherwise raises the AuthenticationFailed error.
     # Thanks to David King and Scott Taylor for Ruby 1.9 fix.
-    def authenticate(username, password, service)
+    def authenticate(options = {})
+      username = options[:username]
+      password = options[:password]
+      service = options[:service]
       @auth_token = nil
       ret = nil
-      ret = send_request(Request.new(:post, AUTH_URL, "Email=#{username}&Passwd=#{password}&source=GCal4Ruby&service=#{service}&accountType=HOSTED_OR_GOOGLE"))
+      auth_args = "Email=#{username}&Passwd=#{password}&source=GCal4Ruby&service=#{service}&accountType=HOSTED_OR_GOOGLE"
+      log(auth_args)
+      ret = send_request(Request.new(:post, @@auth_url, auth_args))
       if ret.class == Net::HTTPOK
         body = ret.read_body
         lines = body.send(body.respond_to?(:lines) ? :lines : :to_s).to_a
@@ -51,8 +58,20 @@ module GData4Ruby
         @password = password
         return true
       else
+        @auth_token = nil
         raise AuthenticationFailed
       end
     end
+    
+    def reauthenticate(options = {})
+      options[:username] ||= @account
+      options[:password] ||= @password
+      authenticate(options)
+    end
+    
+    def authenticated?
+      log("Authenticated: #{@auth_token}")
+      return (@auth_token != nil)
+    end
   end
 end

metadata

@@ -2,7 +2,7 @@
 name: cs210-gdata4ruby
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.5
+  version: 0.2.0
 platform: ruby
 authors: 
 - Mike Reich
@@ -10,10 +10,19 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-13 00:00:00 -07:00
-default_executable: 
-dependencies: []
-
+date: 2011-04-29 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: oauth2
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.4.1
+  type: :runtime
+  version_requirements: *id001
 description: A full featured wrapper for interacting with the base Google Data API, including authentication and basic object handling
 email: mike@seabourneconsulting.com
 executables: []
@@ -28,12 +37,12 @@ files:
 - lib/gdata4ruby.rb
 - lib/gdata4ruby/base.rb
 - lib/gdata4ruby/service.rb
+- lib/gdata4ruby/oauth_service.rb
 - lib/gdata4ruby/request.rb
 - lib/gdata4ruby/gdata_object.rb
 - lib/gdata4ruby/utils/utils.rb
 - lib/gdata4ruby/acl/access_rule.rb
 - test/unit.rb
-has_rdoc: true
 homepage: http://cookingandcoding.com/gdata4ruby/
 licenses: []
 
@@ -57,7 +66,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: gdata4ruby
-rubygems_version: 1.6.1
+rubygems_version: 1.7.2
 signing_key: 
 specification_version: 3
 summary: A full featured wrapper for interacting with the base Google Data API