gdata4ruby 0.1.0

data/CHANGELOG

@@ -0,0 +1,3 @@
+#=CHANGELOG
+#==version 0.1.0
+#* Initial Version

data/README

@@ -0,0 +1,38 @@
+#=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 GPL v2.  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/
+#
+#==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/acl/access_rule.rb

@@ -0,0 +1,126 @@
+# 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
+          service.send_request(Request.new(:delete, @parent.acl_uri+"/user:"+@user, nil, {"If-Match" => "*"}))
+        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
+              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,153 @@
+# 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 'gdata4ruby/request'
+require 'gdata4ruby/utils/utils'
+
+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
+
+    #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'
+    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 do_request(request)
+      ret = nil
+      add_auth_header(request)
+      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
+      
+      while ret.is_a?(Net::HTTPRedirection)
+        puts "Redirect received, resending post" if @debug
+        request.url = ret['location']
+        ret = do_request(request)
+      end
+      if not ret.is_a?(Net::HTTPSuccess)
+        puts "invalid response received: "+ret.code if @debug
+        raise HTTPRequestFailed, ret.body
+      end
+      puts "20x response received\nResponse: \n"+ret.read_body if @debug
+      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
+  end
+end

data/lib/gdata4ruby/gdata_object.rb

@@ -0,0 +1,160 @@
+# 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'
+
+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 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
+    
+    #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 = @etag = @acl_uri = @edit_uri = @parent_uri = @feed_uri = 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 'resourceId'
+            @id = ele.text
+          when 'title'
+            @title = ele.text
+          when 'category'
+            @categories << {:label => ele.attributes['label'], 
+                            :scheme => ele.attributes['scheme'],
+                            :term => ele.attributes['term']}
+          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']
+            end
+          when 'feedLink'
+            @feed_links << {:rel => ele.attributes['rel'], :href => ele.attributes['href']}
+            @acl_uri = ele.attributes['href'] if ele.attributes['rel'].include? 'accessControlList'
+        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
+    
+    #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, @feed_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 and not query_parameters.is_a? Hash
+      @parameters = "?#{query_parameters.to_a.collect{|a| a.join("=")}.join("&")}" if query_parameters
+    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,55 @@
+# 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.
+    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
+        @auth_token = ret.read_body.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,33 @@
+# 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
+    end
+  end
+end

data/lib/gdata4ruby.rb

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

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,63 @@
+--- !ruby/object:Gem::Specification 
+name: gdata4ruby
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Mike Reich
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-28 00:00:00 +10:00
+default_executable: 
+dependencies: []
+
+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
+- 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
+has_rdoc: true
+homepage: http://cookingandcoding.com/gdata4ruby/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: gdata4ruby
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A full featured wrapper for interacting with the base Google Data API
+test_files: 
+- test/unit.rb