vcita-gdata4ruby 0.2.2

data/CHANGELOG

@@ -0,0 +1,20 @@
+=CHANGELOG
+==version 0.2.2
+* Forked by vCita
+* Resolved endless loop bug in redirect
+==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

data/README.md

@@ -0,0 +1,71 @@
+# vcita-GData4Ruby
+
+## 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.
+
+## 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.
+
+OAuth support was added by [edave](https://github.com/edave/)
+
+### Website
+
+http://cookingandcoding.com/gdata4ruby/
+
+## 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
+
+Below are some common usage examples.  For more examples, check the documentation.
+
+### Service
+
+1. Authenticate
+    service = Service.new
+    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.
+
+	my_generic_service = Service.new({:check_public => false})

data/lib/gdata4ruby.rb

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

data/lib/gdata4ruby/acl/access_rule.rb

@@ -0,0 +1,127 @@
+# Author:: Mike Reich (mike@seabourneconsulting.com)
+# Copyright:: Copyright (C) 2010 Mike Reich
+# License:: GPL v2
+#--
+# Licensed under the General Public License (GPL), 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.gnu.org/licenses/old-licenses/gpl-2.0.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/gdata_object'
+
+module GData4Ruby
+  
+  #Contains classes for interacting with Google ACL feeds
+  module ACL
+    
+    #Represents an individual access rule entry in a Google ACL feed.
+    class AccessRule < GDataObject
+      XML = "<entry xmlns='http://www.w3.org/2005/Atom' xmlns:gAcl='http://schemas.google.com/acl/2007'>
+  <category scheme='http://schemas.google.com/g/2005#kind'     
+    term='http://schemas.google.com/acl/2007#accessRule'/>
+  <gAcl:role value=''/>
+  <gAcl:scope type='user' value=''/>
+</entry>"
+
+      #The Rule's user
+      attr_accessor :user
+      
+      #The user's role
+      attr_accessor :role
+      
+      #The parent GDataObject the rule applies to
+      attr_accessor :parent
+      
+      #Creates a new AccessRule object.  You must pass a valid Service and GDataObject, and can pass an optional hash
+      #of attributes to initialize the object with.
+      def initialize(service, parent, attributes = {})
+        super(service, attributes)
+        @xml = XML
+        raise ArgumentError, 'parent must be a GData4Ruby::GDataObject' if not parent.is_a? GData4Ruby::GDataObject
+        @parent = parent
+        @role = @user = nil
+      end
+      
+      #Creates the AccessRule using the parent's acl_uri attribute.
+      def create
+        ret = service.send_request(Request.new(:post, @parent.acl_uri, to_xml))
+        if not ret or not load(ret.read_body)
+          raise SaveFailed, 'Could not create access rule'
+        end
+        return ret
+      end
+      
+      #Loads data into the object.  Accepts a string containing an XML <entry> object.
+      def load(string)
+        super(string)
+        @folders = []
+        xml = REXML::Document.new(string)
+        xml.root.elements.each(){}.map do |ele|
+          case ele.name
+            when 'role'
+              @role = ele.attributes['value']
+            when 'scope'
+              @user = ele.attributes['value'] ? ele.attributes['value'] : ele.attributes['type']
+          end
+        end
+      end
+      
+      #Deletes the AccessRule
+      def delete
+        if @exists
+          @role = 'none'
+          service.send_request(Request.new(:put, @edit_uri, self.to_xml, {"If-Match" => "*", 'Content-Type' => 'application/atom+xml'}))
+        end
+        @exists = false
+        return true
+      end
+      
+      #Finds an AccessRule based on the args passed.  
+      #
+      #Args can be a hash containing either:
+      #*user*:: an email address/user id to search for.  If found, returns the matching AccessRule object.
+      #*role*:: the role to search for.  Returns an array of matching AccessRules, or an empty array if no matches are found.
+      def self.find(service, parent, args = {})
+        raise ArgumentError, 'Must supply a username or role to find by' if not args[:user] and not args[:role]
+        rules = []
+        ret = service.send_request(GData4Ruby::Request.new(:get, parent.acl_uri))
+        xml = REXML::Document.new(ret.read_body).root
+        xml.elements.each("entry") do |e|
+          e = GData4Ruby::Utils::add_namespaces(e)
+          rule = AccessRule.new(service, parent)
+          rule.load(e.to_s)
+          return rule if args[:user] and rule.user == args[:user]
+          rules << rule if args[:role] and rule.role == args[:role]
+        end
+        return args[:user] ? false : rules
+      end
+      
+      #Returns a string containing the XML representation of the AccessRule
+      def to_xml
+        xml = REXML::Document.new(super)
+        xml.root.elements.each(){}.map do |ele|
+          case ele.name
+          when "role"
+            ele.attributes['value'] = @role           
+          when 'scope'
+            if @user and @user != 'default'
+              ele.attributes['value'] = @user 
+            else
+              ele.attributes['type'] = 'default'
+              ele.delete_attribute("value")
+            end
+          end
+        end
+        xml.to_s
+      end
+    end
+  end
+end

data/lib/gdata4ruby/base.rb

@@ -0,0 +1,229 @@
+# Author:: Mike Reich (mike@seabourneconsulting.com)
+# Copyright:: Copyright (C) 2010 Mike Reich
+# License:: GPL v2
+#--
+# Licensed under the General Public License (GPL), 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.gnu.org/licenses/old-licenses/gpl-2.0.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 "net/http"
+require "net/https"
+require 'time'
+require 'cgi'
+require 'gdata4ruby/request'
+require 'gdata4ruby/utils/utils'
+require 'rexml/document'
+
+Net::HTTP.version_1_2
+
+# GData4Ruby is a full featured wrapper for the base google data API
+
+module GData4Ruby
+  
+  class AuthenticationFailed < StandardError; end #:nodoc: all
+
+  class NotAuthenticated < StandardError; end
+    
+  class InvalidService < StandardError; end
+    
+  class HTTPRequestFailed < StandardError; end
+    
+  class QueryParameterError < StandardError; end
+
+  #The ProxyInfo class contains information for configuring a proxy connection
+  
+  class ProxyInfo
+    attr_accessor :address, :port, :username, :password
+    @address = nil
+    @port = nil
+    @username = nil
+    @password = nil
+
+    #The initialize function accepts four variables for configuring the ProxyInfo object.  
+    #The proxy connection is initiated using the builtin Net::HTTP proxy support.
+    
+    def initialize(address, port, username=nil, password=nil)
+      @address = address
+      @port = port
+      @username = username
+      @password = password
+    end
+  end
+  
+  #The Base class includes the basic HTTP methods for communicating with the Google Data API.
+  #You shouldn't use this class directly, rather access the functionality through 
+  #the Service subclass.
+
+  class Base
+    @@auth_url = "https://www.google.com/accounts/ClientLogin"
+    @proxy_info = nil
+    @auth_token = nil
+    @debug = false
+    @gdata_version = '2.1'
+
+    #Contains the ProxyInfo object for using a proxy server
+    attr_accessor :proxy_info
+    
+    #If set to true, debug will dump all raw HTTP requests and responses
+    attr_accessor :debug
+    
+    #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 = {})
+      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
+      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, redirect_count = 0)
+      ret = nil
+
+      add_auth_header(request)
+      set_protocol!(request)
+      http = get_http_object(request.url)
+      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
+            ht.get(request.url.to_s, request.headers)
+          when :post
+            ht.post(request.url.to_s, request.content, request.headers)
+          when :put
+            ht.put(request.url.to_s, request.content, request.headers)
+          when :delete
+            ht.delete(request.url.to_s, request.headers)
+        end
+      end
+
+      while ret.is_a?(Net::HTTPRedirection)
+        if request.same_url?(ret['location']) || redirect_count > 100
+          raise HTTPRequestFailed, "Redirect loop, please validate user"
+        end
+
+        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, redirect_count + 1)
+      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
+
+    def get_http_object(location)
+      if @proxy_info and @proxy_info.address
+	     http = Net::HTTP.new(location.host, location.port, @proxy_info.address, @proxy_info.port, @proxy_info.username, @proxy_info.password)
+      else
+	     http = Net::HTTP.new(location.host, location.port)
+	    end
+      if location.scheme == 'https'
+        #fixed http/http misnaming via JohnMetta
+        log("SSL True")
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+      return http
+    end
+    
+    def add_auth_header(request)
+      if @auth_token
+        if request.headers
+          request.headers.merge!({'Authorization' => "GoogleLogin auth=#{@auth_token}", "GData-Version" => @gdata_version})
+        else 
+          content_type = (request.type == :get or request.type == :delete) ? 'application/x-www-form-urlencoded' : 'application/atom+xml'
+          request.headers = {'Authorization' => "GoogleLogin auth=#{@auth_token}", "GData-Version" => @gdata_version, 'Content-Type' => content_type}
+        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

@@ -0,0 +1,217 @@
+# Author:: Mike Reich (mike@seabourneconsulting.com)
+# Copyright:: Copyright (C) 2010 Mike Reich
+# License:: GPL v2
+#--
+# Licensed under the General Public License (GPL), 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.gnu.org/licenses/old-licenses/gpl-2.0.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/service'
+require 'time'
+
+module GData4Ruby
+  #The GDataObject class represents any <entry> object returned by a Google Service.  Includes
+  #attributes for accessing the common elements/parameters of the object, and methods for CRUD
+  #operations.
+  class GDataObject    
+    #A Service object
+    attr_accessor :service
+    
+    #The entry title.
+    attr_accessor :title
+    
+    #The raw date the document was published
+    attr_reader :published
+    
+    #The raw date the document was last updated
+    attr_reader :updated
+    
+    #The author/owner name
+    attr_reader :author_name
+    
+    #The author/owner email
+    attr_reader :author_email
+    
+    #The current instance etag for the entry
+    attr_reader :etag
+    
+    #The parent URI, if any
+    attr_reader :parent_uri
+
+    #The edit URI, for making changes to the entry
+    attr_reader :edit_uri
+    
+    #A hash of additional feedLinks
+    attr_reader :feed_links
+    
+    #The unique entry id, as represented by the <gd:resourceId> tag.  Not to be confused
+    #with the Atom <id> tag, which is accessible as the feed_uri attribute.
+    attr_reader :id
+    
+    #The entry's feed uri, otherwise known as the Atom <id> element value.
+    attr_reader :feed_uri
+    
+    #A hash of categories
+    attr_reader :categories
+    
+    #The feedLink that represents the entry's ACL feed.
+    attr_reader :acl_uri
+    
+    #The content uri for exporting the object content
+    attr_reader :content_uri
+    
+    #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
+    end
+    
+    #Initializes a new GDataObject.  You must pass a valid Service object, and can pass
+    #an optional array of attributes to initialize values.  To load data into an object,
+    #use the load method.
+    def initialize(service, attributes = {})
+      @xml ||= ''
+      @service ||= service
+      @exists = false
+      @title = @content_uri = @etag = @acl_uri = @edit_uri = @parent_uri = @feed_uri = @kind = nil
+      @categories = @feed_links = []
+      @include_etag = true
+      attributes.each do |key, value|
+        if self.respond_to?("#{key}=")
+          self.send("#{key}=", value)
+        end
+      end
+    end
+    
+    public
+    #Loads data into the object.  Accepts a string containing an XML <entry> from a GData
+    #compliant feed.
+    def load(string)
+      @exists = @include_etag = true
+      @xml = string
+      xml = REXML::Document.new(string)
+      xml.root.elements.each(){}.map do |ele|
+        @etag = xml.root.attributes['etag'] if xml.root.attributes['etag']
+        case ele.name
+          when "id"
+            @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'],
+                            :term => ele.attributes['term']}
+            if ele.attributes['scheme'] and ele.attributes['scheme'] == 'http://schemas.google.com/g/2005#kind'
+              @kind = if ele.attributes['label'] 
+                ele.attributes['label'] 
+              else
+                ele.attributes['term']
+              end
+            end
+          when 'link'
+            case ele.attributes['rel']
+              when 'http://schemas.google.com/docs/2007#parent'
+                @parent_uri = ele.attributes['href']
+              when 'edit'
+                @edit_uri = ele.attributes['href']
+              when 'http://schemas.google.com/acl/2007#accessControlList'
+                @acl_uri = ele.attributes['href'] if not @acl_uri
+            end
+          when 'feedLink'
+            @feed_links << {:rel => ele.attributes['rel'], :href => ele.attributes['href']}
+            @acl_uri = ele.attributes['href'] if ele.attributes['rel'].include? 'accessControlList' and not @acl_uri
+          when 'author'
+            ele.elements.each('name'){}.map {|e| @author_name = e.text}
+            ele.elements.each('email'){}.map {|e| @author_email = e.text}
+          when 'published'
+            begin
+              @published = Time.parse(ele.text)
+            rescue
+              @published = nil
+	    end
+          when 'updated'
+            begin
+              @updated = Time.parse(ele.text)
+            rescue
+              @updated = nil
+            end 
+        end
+      end
+      return xml.root
+    end
+    
+    #Saves the object if it exsits, otherwise creates it.
+    def save
+      if @exists
+        ret = service.send_request(Request.new(:put, @edit_uri, to_xml))
+      else
+        ret = create
+      end
+      if not ret or not load(ret.read_body)
+        raise SaveFailed, 'Could not save object'
+      end
+      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.
+    def create
+      return false
+    end
+    
+    #Deletes the object.
+    def delete
+      if @exists
+        service.send_request(Request.new(:delete, @edit_uri, nil, {"If-Match" => "*"}))
+      end
+      @exists = false
+      return true
+    end
+    
+    #Creates a new string containing the XML representation of the object as a GData compliant <entry>
+    #element.
+    def to_xml
+      xml = REXML::Document.new(@xml)
+      xml.root.elements.each(){}.map do |ele|
+        if @include_etag
+          xml.root.attributes['gd:etag'] = @etag if @etag and @etag != ''
+        else
+          xml.root.delete_attribute('gd:etag')
+        end
+        case ele.name
+        when "title"
+          ele.text = @title
+        end
+      end
+      xml.to_s
+    end
+  end
+end

data/lib/gdata4ruby/oauth_service.rb

@@ -0,0 +1,100 @@
+# 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, redirect_count = 0)
+      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)
+        if request.same_url?(ret['location']) || redirect_count > 100
+          raise HTTPRequestFailed, "Redirect loop, please validate user"
+        end
+
+        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, redirect_count + 1)
+      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/request.rb

@@ -0,0 +1,66 @@
+# Author:: Mike Reich (mike@seabourneconsulting.com)
+# Copyright:: Copyright (C) 2010 Mike Reich
+# License:: GPL v2
+#--
+# Licensed under the General Public License (GPL), 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.gnu.org/licenses/old-licenses/gpl-2.0.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 "uri"
+
+module GData4Ruby
+  #The Request class holds all information needed to make a Request to a Google service.
+  class Request
+    #The HTTP request type, must be one of :get, :post, :put, :delete
+    attr_accessor :type
+    
+    #The HTTP request content, only valid for :put and :post requests
+    attr_accessor :content
+    
+    #Optional.  Additional headers to pass with the request.
+    attr_accessor :headers
+    
+    #Optional.  Additional query parameters (i.e. "?param=value") to append to the request url
+    attr_reader :parameters
+    
+    #Creates a new request object.
+    def initialize(type, url, content = nil, headers = nil, query_parameters = nil)
+      @parameters = nil
+      @headers = headers
+      @content = content
+      @type = type
+      @url = URI.parse(url)
+      self.parameters = query_parameters
+    end
+    
+    #The HTTP url to send the request to
+    def url=(new_url)
+      @given_url_string = new_url if new_url.is_a?(String)
+      @url = new_url
+    end
+    
+    #A hash of additional query parameters (i.e. {'param' => 'value') to append to the request url
+    def parameters=(query_parameters) 
+      raise ArgumentError, 'Query parameters must be a Hash' if query_parameters != nil and not query_parameters.is_a? Hash
+      @parameters = query_parameters.is_a?(Hash) ? "?#{query_parameters.to_a.collect{|a| a.join("=")}.join("&")}" : nil
+    end
+
+    def same_url?(other_url)
+      return @given_url_string == other_url
+    end
+    
+    #The HTTP url to send the request to
+    def url
+      return URI.parse("#{@url+(@parameters ? @parameters : '')}")
+    end
+  end
+end

data/lib/gdata4ruby/service.rb

@@ -0,0 +1,77 @@
+# Author:: Mike Reich (mike@seabourneconsulting.com)
+# Copyright:: Copyright (C) 2010 Mike Reich
+# License:: GPL v2
+#--
+# Licensed under the General Public License (GPL), 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.gnu.org/licenses/old-licenses/gpl-2.0.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 Service < Base
+    #Convenience attribute contains the currently authenticated account name
+    attr_reader :account
+    
+    # The token returned by the Google servers, used to authorize all subsequent messages
+    attr_reader :auth_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 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(options = {})
+      username = options[:username]
+      password = options[:password]
+      service = options[:service]
+      @auth_token = nil
+      ret = nil
+      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
+        @auth_token = lines.to_a[2].gsub("Auth=", "").strip
+        @account = username
+        @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

data/lib/gdata4ruby/utils/utils.rb

@@ -0,0 +1,35 @@
+# Author:: Mike Reich (mike@seabourneconsulting.com)
+# Copyright:: Copyright (C) 2010 Mike Reich
+# License:: GPL v2
+#--
+# Licensed under the General Public License (GPL), 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.gnu.org/licenses/old-licenses/gpl-2.0.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.
+#++
+module GData4Ruby
+  #A helper class that includes commonly used utility methods.
+  class Utils
+    #Adds common Google namespaces to an element.  Useful for processing individual events returned from in a feed.
+    def self.add_namespaces(entry)
+      entry.attributes["xmlns:openSearch"] = "http://a9.com/-/spec/opensearch/1.1/"
+      entry.attributes["xmlns:gAcl"] = "http://schemas.google.com/acl/2007"
+      entry.attributes["xmlns:gCal"] = "http://schemas.google.com/gCal/2005"
+      entry.attributes["xmlns:gd"] = "http://schemas.google.com/g/2005"
+      entry.attributes["xmlns:app"] = "http://www.w3.org/2007/app"
+      entry.attributes["xmlns:docs"] = "http://schemas.google.com/docs/2007"
+      entry.attributes["xmlns"] = "http://www.w3.org/2005/Atom"
+      entry.attributes["xmlns:georss"] = "http://www.georss.org/georss"
+      entry.attributes["xmlns:gml"] = "http://www.opengis.net/gml"
+      entry
+    end
+  end
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification 
+name: vcita-gdata4ruby
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: 
+  segments: 
+  - 0
+  - 2
+  - 2
+  version: 0.2.2
+platform: ruby
+authors: 
+- Mike Reich
+- Anthony Underwood
+- David Pitman
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-12-09 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: oauth
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 0
+        - 4
+        - 4
+        version: 0.4.4
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: 
+- mike@seabourneconsulting.com
+- email2ants@gmail.com
+- ui-design@vestaldesign.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- CHANGELOG
+- README.md
+- lib/gdata4ruby.rb
+- lib/gdata4ruby/acl/access_rule.rb
+- lib/gdata4ruby/base.rb
+- lib/gdata4ruby/gdata_object.rb
+- lib/gdata4ruby/oauth_service.rb
+- lib/gdata4ruby/request.rb
+- lib/gdata4ruby/service.rb
+- lib/gdata4ruby/utils/utils.rb
+has_rdoc: true
+homepage: https://github.com/vcita/GData4Ruby
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A full featured wrapper for interacting with the base Google Data API
+test_files: []
+