intouch-gdata4ruby 0.1.5

data/CHANGELOG

@@ -0,0 +1,16 @@
+#=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
+#* 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,45 @@
+#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.
+
+##Website
+
+[http://cookingandcoding.com/gdata4ruby/](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.
+
+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("user@gmail.com", "password", "cl")
+
+2. Authenticate with a specified GData version
+
+    service = Service.new({:gdata_version => '3.0'})
+    service.authenticate("user@gmail.com", "password", "cl")

data/lib/gdata4ruby.rb

@@ -0,0 +1 @@
+require "gdata4ruby/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.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.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,213 @@
+# 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'
+    @session_cookie = nil
+
+    #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 = attributes[:gdata_version] ? attributes[:gdata_version] : '2.1'
+      @use_ssl ||= false
+    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
+      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)
+      set_protocol!(request)
+      # Add the session cookie if available
+      request.headers.merge!({'Cookie' => @session_cookie}) if @session_cookie
+      http = get_http_object(request.url)
+      puts "Sending request\nHeader: #{request.headers.inspect.to_s}\nContent: #{request.content.to_s}\n" if @debug
+      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
+
+      if @debug
+        puts "Response code: #{ret.status}"
+        puts "Headers: \n"
+        ret.headers.each { |h, v| puts "#{h}:#{v}" }
+        puts "Body: \n" + ret.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
+
+      if not ret.success?
+        puts "invalid response received: "+ret.status if @debug
+        raise HTTPRequestFailed, ret.body
+      end
+      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
+        puts "SSL True" if @debug
+        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,197 @@
+# 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
+    
+    #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|
+        self.send("#{key}=", value)
+      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"
+            puts 'setting id' if service.debug
+            @feed_uri = ele.text
+          when 'content'
+            @content_uri = ele.attributes['src'] if ele.attributes['src']
+          when 'resourceId'
+            @id = ele.text
+          when 'title'
+            @title = ele.text
+          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'
+            @published = Time.parse(ele.text) rescue nil
+          when 'updated'
+            @updated = Time.parse(ele.text) rescue nil
+        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.body)
+        raise SaveFailed, 'Could not save object'
+      end
+      return true
+    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/request.rb

@@ -0,0 +1,61 @@
+# 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)
+      @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
+    
+    #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,58 @@
+# 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|
+        self.send("#{key}=", value)
+      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)
+      @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"))
+      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
+        raise AuthenticationFailed
+      end
+    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

data/test/unit.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/ruby
+
+require 'rubygems'
+require 'gdata4ruby'
+include GData4Ruby
+
+@service = Service.new
+@username = nil
+@password = nil
+
+def tester
+  if ARGV.include?("-d")
+      @service.debug = true
+  end
+  ARGV.each do |ar|
+    if ar.match("username=")
+      @username = ar.gsub("username=", "")
+    end
+    if ar.match("password=")
+      @password = ar.gsub("password=", "")
+    end
+  end
+  service_test
+end
+
+def service_test
+  puts "---Starting Service Test---"
+  puts "1. Authenticate"
+  if @service.authenticate(@username, @password, 'cl')
+    successful
+  else
+    failed
+  end
+  
+  puts "2. Authenticate with GData version 3.0"
+  @service = Service.new({:gdata_version => '3.0'})
+  if @service.authenticate(@username, @password, 'cl') and @service.gdata_version == '3.0'
+    successful
+  else
+    failed
+  end
+end
+
+def failed(m = nil)
+  puts "Test Failed"
+  puts m if m
+  exit()
+end
+
+def successful(m = nil)
+  puts "Test Successful"
+  puts m if m
+end
+
+tester

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: intouch-gdata4ruby
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.5
+platform: ruby
+authors: 
+- Mike Reich
+autorequire: 
+bindir: bin
+cert_chain: []
+
+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: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- CHANGELOG
+- lib/gdata4ruby.rb
+- lib/gdata4ruby/base.rb
+- lib/gdata4ruby/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
+homepage: http://cookingandcoding.com/gdata4ruby/
+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: gdata4ruby
+rubygems_version: 1.7.2
+signing_key: 
+specification_version: 3
+summary: A full featured wrapper for interacting with the base Google Data API
+test_files: 
+- test/unit.rb