gdocs4ruby 0.1.0

data/CHANGELOG

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

data/README

@@ -0,0 +1,76 @@
+#=GDocs4Ruby
+#
+#==Introduction
+#GDocs4Ruby is a full featured wrapper for version 2.0 of the Google Documents API (aka DocList).  GDocs4Ruby provides the ability
+#to create, update and delete google documents, metadata and content.  The gem also includes support for folders, modifying
+#permissions for documents via ACL feeds, and much more.
+#
+#GDocs4Ruby uses the GData4Ruby Gem for interacting with the Google API.  Check out http://cookingandcoding.com/gdata4ruby for 
+#other Google API Libraries based using GData4Ruby.
+#
+#==Author and Contact Information
+#GDocs4Ruby 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/gdocs4ruby/
+#
+#==Description
+#GDocs4Ruby includes the following classes: Service, Folder, BaseObject, Spreadsheet, Document, Presentation.
+#
+#The Service object provides functionality for authenticating with the Google Documents API, grabbing a list of 
+#documents and a list of folders associated with the account.
+#
+#Interacting with objects is done by using the associated subclass of BaseObject, i.e. Document.  Every object
+#class supports the same inherited methods for creating, updating and deleting, in addition to changing
+#ACL permissions, and adding and removing from various folders.
+#
+#==Examples
+#Below are some common usage examples.  For more examples, check the documentation.  Also, check out the example code
+#for integrating with Rails at http://cookingandcoding.com/gdocs4ruby/example/
+#===Service
+#1. Authenticate
+#    service = Service.new
+#    service.authenticate("user@gmail.com", "password")
+#
+#2. Get Document List
+#    documents = service.files
+#
+#3. Get Folder List
+#    folders = serivce.folders
+#
+#===Documents
+#1. Create a new Document
+#    doc = Document.new(@service)
+#    doc.title = 'Test Document'
+#    doc.content = '<h1>Test Content HTML</h1>'
+#    doc.content_type = 'html'
+#    doc.save
+#
+#2. Deleting a Document
+#    doc = Document.find(@service, {:id => @doc_id})
+#    doc.delete
+#
+#3. Finding an existing Document by id
+#    doc = Document.find(@service, {:id => @doc_id})
+#
+#4. Full Text Query
+#    doc = Document.find(@service, 'content text')
+#
+#   or
+#
+#    doc = Document.find(@service, {:query => 'content text'})
+#
+#5. Finding an Existing Document by Title
+#    doc = Document.find(@service, nil, {'title' => 'Test Document'})
+#
+#6. Updating a Document with Content from a Local File
+#    doc = Document.find(@service, {:id => @doc_id})
+#    doc.title = 'New Title'
+#    doc.local_file = '/path/to/some/file'
+#    doc.save
+#
+#7. Retrieving an Export
+#    doc = Document.find(@service, {:id => @doc_id})
+#    doc.download_to_file('pdf', '/path/to/save/location.pdf')
+

data/lib/gdocs4ruby/base_object.rb

@@ -0,0 +1,408 @@
+# 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'
+require 'gdata4ruby/acl/access_rule'
+
+module GDocs4Ruby
+  
+  #The base object class that includes all major methods for interacting with Google Documents API.
+  #=Usage
+  #All usages assume you've already authenticated with the service, and have a service object called
+  #@service.  
+  #*Note*: You probably don't want to instantiate a BaseObject directly, but rather use any of the subclasses
+  #Document, Spreadsheet, and Presentation
+  #1. Create a new Document
+  #    doc = BaseObject.new(@service)
+  #    doc.title = 'Test Document'
+  #    doc.content = '<h1>Test Content HTML</h1>'
+  #    doc.content_type = 'html'
+  #    doc.save
+  #
+  #2. Deleting a Document
+  #    doc = BaseObject.find(@service, {:id => @doc_id})
+  #    doc.delete
+  #
+  #3. Finding an existing Document by id
+  #    doc = BaseObject.find(@service, {:id => @doc_id})
+  #
+  #4. Full Text Query
+  #    doc = BaseObject.find(@service, 'content text')
+  #
+  #   or
+  #
+  #    doc = BaseObject.find(@service, {:query => 'content text'})
+  #
+  #5. Finding an Existing Document by Title
+  #    doc = BaseObject.find(@service, nil, 'any', {'title' => 'Test Document'})
+  #
+  #6. Updating a Document with Content from a Local File
+  #    doc = BaseObject.find(@service, {:id => @doc_id})
+  #    doc.title = 'New Title'
+  #    doc.local_file = '/path/to/some/file'
+  #    doc.save
+  
+  class BaseObject < GData4Ruby::GDataObject
+    ENTRY_XML = '<atom:entry xmlns:atom="http://www.w3.org/2005/Atom">
+  <atom:title></atom:title>
+</atom:entry>'
+    BOUNDARY = 'GDOCS4RUBY_BOUNDARY'
+    UPLOAD_TYPES = {'' => 'text/txt',
+                :csv => 'text/csv', 
+                :tsv => 'text/tab-separated-values', 
+                :tab => 'text/tab-separated-values',
+                :html => 'text/html',
+                :htm => 'text/html',
+                :doc => 'application/msword',
+                :docx => 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+                :ods => 'application/x-vnd.oasis.opendocument.spreadsheet',
+                :odt => 'application/vnd.oasis.opendocument.text',
+                :rtf => 'application/rtf',
+                :sxw => 'application/vnd.sun.xml.writer',
+                :txt => 'text/plain',
+                :xls => 'application/vnd.ms-excel',
+                :xlsx => 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+                :pdf => 'application/pdf',
+                :ppt => 'application/vnd.ms-powerpoint',
+                :pps => 'application/vnd.ms-powerpoint',
+                :pptx => 'application/vnd.ms-powerpoint'}
+                
+    FEEDS = {:document => "https://docs.google.com/feeds/documents/private/full/",
+             :folder => "http://docs.google.com/feeds/folders/private/full/",
+             :spreadsheet => "https://docs.google.com/feeds/documents/private/full/",
+             :presentation => "https://docs.google.com/feeds/documents/private/full/",
+             :any => "https://docs.google.com/feeds/documents/private/full/"}
+             
+    QUERY_FEEDS = {:document => "https://docs.google.com/feeds/documents/private/full/-/document",
+             :folder => "http://docs.google.com/feeds/folders/private/full/?showfolders=true",
+             :spreadsheet => "https://docs.google.com/feeds/documents/private/full/-/spreadsheet",
+             :presentation => "https://docs.google.com/feeds/documents/private/full/-/presentation",
+             :any => "https://docs.google.com/feeds/documents/private/full/"}
+             
+    TYPES = ["document", "folder", "spreadsheet", "presentation", "any"]
+    
+    #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
+    
+    #An array of folders this object belongs to
+    attr_reader :folders
+    
+    #Quota bytes used by the document
+    attr_reader :bytes_used
+    
+    #The type of the object, one of TYPES
+    attr_reader :type
+    
+    #The uri for the html editor of the object (the web editor for documents)
+    attr_reader :html_uri
+    
+    #The content uri for exporting the object content
+    attr_reader :content_uri
+    
+    #Flag indicating whether the document has the 'viewed' category link.
+    attr_reader :viewed
+    
+    #A local file to upload content from
+    attr_accessor :local_file
+    
+    #Creates a new BaseObject instance.  Requires a valid GData4Ruby::Service object.
+    def initialize(service, attributes = {})
+      super(service, attributes)
+      @xml = ENTRY_XML
+      @folders = []
+      @content_uri = nil
+      @edit_content_uri = nil
+      @viewed = false
+      @content = @content_type = nil
+    end
+    
+    public
+    #Loads a string containing an XML <entry> from a Google API feed.
+    def load(string)
+      super(string)
+      @folders = []
+      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 'published'
+            @published = ele.text
+          when 'updated'
+            @updated = ele.text
+          when 'content'
+            @content_uri = ele.attributes['src']
+          when 'link'
+            case ele.attributes['rel']
+              when 'edit-media'
+                @edit_content_uri = ele.attributes['href']
+              when 'alternate'
+                @html_uri = ele.attributes['href']
+            end
+          when 'author'
+            ele.elements.each('name'){}.map {|e| @author_name = e.text}
+            ele.elements.each('email'){}.map {|e| @author_email = e.text}
+          when 'quotaBytesUsed'
+            @bytes_used = ele.text
+        end
+      end
+      @categories.each do |cat|
+        @folders << cat[:label] if cat[:scheme] and cat[:scheme].include? "folders"
+        @viewed = true if cat[:label] and cat[:label] == 'viewed'
+        @type = cat[:label] if cat[:scheme] and cat[:scheme] == 'http://schemas.google.com/g/2005#kind'
+      end
+      return xml.root
+    end
+    
+    #Sets content to save to the document.  Content must be formatted as one of the types in UPLOAD_TYPES.
+    def content=(value)
+      @content = value
+    end
+    
+    #Sets the content_type stored in content. content_type must be one of the keys in UPLOAD_TYPES.
+    def content_type=(value)
+      @content_type = value
+    end
+    
+    #Saves or creates the object depending on whether it exists or not.
+    def save
+      if @exists
+        if (not @local_file.nil? and @local_file.is_a? String) or @content
+          @include_etag = false
+          if @local_file
+            ret = service.send_request(GData4Ruby::Request.new(:put, @edit_content_uri, create_multipart_message([{:type => 'application/atom+xml', :content => to_xml()}, {:type => UPLOAD_TYPES[File.extname(@local_file).gsub(".", "").to_sym], :content => get_file(@local_file).read}]), {'Content-Type' => "multipart/related; boundary=#{BOUNDARY}", 'Content-Length' => File.size(@local_file).to_s, 'Slug' => File.basename(@local_file), 'If-Match' => "*"}))
+          elsif @content
+            ret = service.send_request(GData4Ruby::Request.new(:put, @edit_content_uri, create_multipart_message([{:type => 'application/atom+xml', :content => to_xml()}, {:type => UPLOAD_TYPES[@content_type.to_sym], :content => @content}]), {'Content-Type' => "multipart/related; boundary=#{BOUNDARY}", 'Content-Length' => @content.size.to_s, 'Slug' => @title, 'If-Match' => "*"}))
+          end
+        else
+          ret = service.send_request(GData4Ruby::Request.new(:put, @edit_uri, to_xml()))
+        end
+        if not load(ret.read_body)
+          raise SaveFailed
+        end
+        return true
+      else
+        return create
+      end
+    end
+          
+    #Retrieves an array of GData4Ruby::AccessRules representing the access rules for the object, as contained in the Google ACL.
+    def access_rules
+      rules = []
+      ret = service.send_request(GData4Ruby::Request.new(:get, @acl_uri))
+      xml = REXML::Document.new(ret.read_body).root
+      xml.elements.each("entry") do |e|
+        ele = GData4Ruby::Utils::add_namespaces(e)
+        rule = GData4Ruby::ACL::AccessRule.new(service, self)
+        puts ele.to_s if service.debug
+        rule.load(ele.to_s)
+        rules << rule
+      end
+      rules
+    end
+    
+    #Adds a new access rule for the object.  Parameters are:
+    #*user*::  the user (email address) to add permissions for
+    #*role*::  can be one of 'viewer' or 'writer' depending on whether the user should be able to edit or read only.
+    def add_access_rule(user, role)
+      a = GData4Ruby::ACL::AccessRule.new(service, self)
+      a.user = user
+      a.role = role
+      a.save
+    end
+    
+# Waiting for V3 to graduate    
+#    def set_publicly_writable(value)
+#      if value
+#        a = GData4Ruby::ACL::AccessRule.new(service, self)
+#        a.role = 'writer'
+#        a.save
+#      else
+#        remove_access_rule('default', 'writer')
+#      end
+#    end
+    
+# Waiting for V3 to graduate 
+#    def set_publicly_readable(value)
+#      if value
+#        a = GData4Ruby::ACL::AccessRule.new(service, self)
+#        a.role = 'reader'
+#        a.save
+#      else
+#        remove_access_rule('default', 'reader')
+#      end
+#    end
+    
+    #Updates an existing access rule for the object.  Parameters are:
+    #*user*::  the user (email address) to update permissions
+    #*role*::  can be one of 'viewer' or 'writer' depending on whether the user should be able to edit or read only.
+    def update_access_rule(user, role)
+      a = GData4Ruby::ACL::AccessRule.find(service, self, {:user => user})
+      if a
+        a.role = role
+        if a.save
+          return true
+        end
+      end
+      return false
+    end
+    
+    #Removes an access rule for the specified user.  Parameter should be a valid user Id (email address).
+    def remove_access_rule(user)
+      a = GData4Ruby::ACL::AccessRule.find(service, self, {:user => user})
+      if a
+        if a.delete
+          return true
+        end
+      end
+      return false
+    end
+    
+    #Creates a new object instance on the Google server if the object doesn't already exist.
+    def create
+      ret = if (not @local_file.nil? and @local_file.is_a? String) or @content
+        if @local_file
+          service.send_request(GData4Ruby::Request.new(:post, DOCUMENT_LIST_FEED, create_multipart_message([{:type => 'application/atom+xml', :content => to_xml()}, {:type => UPLOAD_TYPES[File.extname(@local_file).gsub(".", "").to_sym], :content => get_file(@local_file).read}]), {'Content-Type' => "multipart/related; boundary=#{BOUNDARY}", 'Content-Length' => File.size(@local_file).to_s, 'Slug' => File.basename(@local_file)}))
+        elsif @content
+          service.send_request(GData4Ruby::Request.new(:post, DOCUMENT_LIST_FEED, create_multipart_message([{:type => 'application/atom+xml', :content => to_xml()}, {:type => UPLOAD_TYPES[@content_type.to_sym], :content => @content}]), {'Content-Type' => "multipart/related; boundary=#{BOUNDARY}", 'Content-Length' => @content.size.to_s, 'Slug' => @title}))
+        end      
+      else
+        service.send_request(GData4Ruby::Request.new(:post, DOCUMENT_LIST_FEED, to_xml()))
+      end
+      if not load(ret.read_body)
+        raise SaveFailed
+      end
+      return ret
+    end
+    
+    #Returns a simple iframe containing the html_uri link for the document.  
+    #
+    #*Note:* you must either be logged in to Google
+    #as the owner of the document for this to work, or have appropriate read/write permissions set up on the document.
+    def to_iframe(options = {})
+      width = options[:width] || '800'
+      height = options[:height] || '500'
+      return "<iframe height='#{height}' width='#{width}' src='#{@html_uri}'></iframe>"
+    end
+    
+    #Saves arbitrary content to the object.  Parameters must be:
+    #*content*:: the content to upload.  Content should be formatted as one of the UPLOAD_TYPES.
+    #*type*:: an optional paramter specifying the type, if not HTML.  This value must be a mime-type enumerated in UPLOAD_TYPES.
+    def put_content(content, type = 'text/html')
+      ret = service.send_request(GData4Ruby::Request.new(:put, @edit_content_uri, content, {'Content-Type' => type, 
+                                                 'Content-Length' => content.length.to_s,
+                                                 'If-Match' => "*"}))
+      load(ret.body)
+    end
+    
+    #Finds a BaseObject based on a text query or by an id.  Parameters are:
+    #*service*::  A valid Service object to search.
+    #*query*:: either a string containing a text query to search by, or a hash containing an +id+ key with an associated id to find, or a +query+ key containint a text query to search for.
+    #*type*:: used to limit results to a specific document type, as list in TYPES.
+    #*args*:: a hash containing optional additional query paramters to use.  See http://code.google.com/apis/gdata/docs/2.0/reference.html#Queries for a full list of possible values.  Example: 
+    # {'max-results' => '100'}
+    #If an ID is specified, a single instance of the document is returned if found, otherwise false.
+    #If a query term is specified, and array of matching results is returned, or an empty array if nothing
+    #was found.
+    def self.find(service, query, type = 'any', args = {})      
+      raise ArgumentError, 'query must be a hash or string' if not query.is_a? Hash and not query.is_a? String
+      raise ArgumentError, "type must be one of #{TYPES.join(" ")}" if not TYPES.include? type
+      if query.is_a? Hash and query[:id]
+        id = query[:id]
+        puts "id passed, finding event by id" if service.debug
+        puts "id = "+id if service.debug
+        d = service.send_request(GData4Ruby::Request.new(:get, FEEDS[type.to_sym]+id, {"If-Not-Match" => "*"}))
+        puts d.inspect if service.debug
+        if d
+          return get_instance(service, d)
+        end
+      else
+        results = []
+        term = query.is_a?(Hash) ? CGI::escape(query[:query]) : CGI::escape(query)
+        args["q"] = term if term and term != ''
+        ret = service.send_request(GData4Ruby::Request.new(:get, QUERY_FEEDS[type.to_sym], nil, nil, args))
+        xml = REXML::Document.new(ret.body).root
+        xml.elements.each("entry") do |e|
+          results << get_instance(service, e)
+        end
+        return results
+      end
+      return false
+    end
+    
+    #Adds the object to the specified folder.  The parameter must be a valid Folder object.
+    def add_to_folder(folder)
+      raise ArgumentError, 'folder must be a GDocs4Ruby::Folder' if not folder.is_a? Folder
+      @service.send_request(GData4Ruby::Request.new(:post, folder.content_uri, to_xml))
+    end
+    
+    #Removes the object from the specified folder.  The parameter must be a valid Folder object.
+    def remove_from_folder(folder)
+      raise ArgumentError, 'folder must be a GDocs4Ruby::Folder' if not folder.is_a? Folder
+      @service.send_request(GData4Ruby::Request.new(:delete, folder.content_uri+"/"+CGI::escape(id), nil, {"If-Match" => "*"}))
+    end
+    
+    private
+    def self.get_instance(service, d)
+      if d.is_a? Net::HTTPOK
+        xml = REXML::Document.new(d.read_body).root
+        if xml.name == 'feed'
+          xml = xml.elements.each("entry"){}[0]
+        end
+      else
+        xml = d
+      end
+      ele = GData4Ruby::Utils::add_namespaces(xml)
+      obj = BaseObject.new(service)
+      obj.load(ele.to_s)
+      case obj.type
+        when 'document'
+          doc = Document.new(service)
+        when 'spreadsheet'
+          doc = Spreadsheet.new(service)
+        when 'folder'
+          doc = Folder.new(service)
+        when 'presentation'
+          doc = Presentation.new(service)
+      end
+      doc.load(ele.to_s)
+      doc
+    end
+    
+    def get_file(filename)
+      file = File.open(filename, "rb")
+      raise FileNotFoundError if not file
+      return file
+    end
+    
+    def create_multipart_message(parts)
+      ret = ''
+      parts.each do |p|
+        ret += "--#{BOUNDARY}\nContent-Type: #{p[:type]}\n\n#{p[:content]}\n\n"
+      end
+      ret += "--#{BOUNDARY}--\n"
+    end
+  end
+end

data/lib/gdocs4ruby/document.rb

@@ -0,0 +1,97 @@
+# 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 GDocs4Ruby
+  #The Document class represents a Google Word Document.  Also check out BaseObject, the superclass of Document.
+  #=Usage
+  #All usages assume you've already authenticated with the service, and have a service object called
+  #@service.  
+  #1. Create a new Document
+  #    doc = Document.new(@service)
+  #    doc.title = 'Test Document'
+  #    doc.content = '<h1>Test Content HTML</h1>'
+  #    doc.content_type = 'html'
+  #    doc.save
+  #
+  #2. Deleting a Document
+  #    doc = Document.find(@service, {:id => @doc_id})
+  #    doc.delete
+  #
+  #3. Finding an existing Document by id
+  #    doc = Document.find(@service, {:id => @doc_id})
+  #
+  #4. Full Text Query
+  #    doc = Document.find(@service, 'content text')
+  #
+  #   or
+  #
+  #    doc = Document.find(@service, {:query => 'content text'})
+  #
+  #5. Finding an Existing Document by Title
+  #    doc = Document.find(@service, nil, {'title' => 'Test Document'})
+  #
+  #6. Updating a Document with Content from a Local File
+  #    doc = Document.find(@service, {:id => @doc_id})
+  #    doc.title = 'New Title'
+  #    doc.local_file = '/path/to/some/file'
+  #    doc.save
+  #
+  #7. Retrieving an Export
+  #    doc = Document.find(@service, {:id => @doc_id})
+  #    doc.download_to_file('pdf', '/path/to/save/location.pdf')
+  
+  class Document < BaseObject
+    DOCUMENT_XML = '<?xml version="1.0" encoding="UTF-8"?>
+<atom:entry xmlns:atom="http://www.w3.org/2005/Atom">
+  <atom:category scheme="http://schemas.google.com/g/2005#kind"
+      term="http://schemas.google.com/docs/2007#document" label="document"/>
+  <atom:title>example document</atom:title>
+</atom:entry>'
+    DOWNLOAD_TYPES = ['doc', 'html', 'odt', 'pdf', 'png', 'rtf', 'txt', 'zip']
+    EXPORT_URI = 'https://docs.google.com/feeds/download/documents/Export'
+    
+    #Creates a new Document instance.  Requires a valid Service object.
+    def initialize(service, attributes = {})
+      super(service, attributes)
+      @xml = DOCUMENT_XML
+    end
+    
+    #Retrieves an export of the Document.  The parameter +type+ must be one of the DOWNLOAD_TYPES.
+    def get_content(type)
+      if !@exists
+        raise DocumentDoesntExist
+      end
+      if not DOWNLOAD_TYPES.include? type
+        raise ArgumentError
+      end
+      ret = service.send_request(GData4Ruby::Request.new(:get, EXPORT_URI, nil, nil, {"docId" => @id,"exportFormat" => type}))
+      ret.body
+    end
+    
+    #Helper function limit queries to Documents.  See BaseObject#find for syntax.  Type is not required and assumed to be 'document'.
+    def self.find(service, query, args = {})
+      super(service, query, 'document', args)
+    end
+    
+    #Downloads the export retrieved through get_content to a specified local file.  Parameters are:
+    #*type*:: must be a valid type enumerated in DOWNLOAD_TYPES
+    #*location*:: a valid file location for the local system
+    def download_to_file(type, location)
+      File.open(location, 'wb+') {|f| f.write(get_content(type)) }
+    end
+  end
+end

data/lib/gdocs4ruby/folder.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.
+#++
+module GDocs4Ruby
+  #The Document class represents a Google Documents Folder.
+  #=Usage
+  #Assumes a valid and authenticated @service object.
+  #1. Retrieving a list of folders
+  #    @service.folders
+  #
+  #2. Getting a list of files in a folder
+  #    @folder = @service.folders.first
+  #    @folder.files
+  #
+  #3. Getting a list of sub folders in a folder
+  #    @folder = @service.folders.first
+  #    @folder.sub_folders
+  #
+  class Folder < BaseObject
+      FOLDER_XML = '<?xml version="1.0" encoding="UTF-8"?>
+<atom:entry xmlns:atom="http://www.w3.org/2005/Atom">
+  <atom:category scheme="http://schemas.google.com/g/2005#kind"
+      term="http://schemas.google.com/docs/2007#folder" label="folder"/>
+  <atom:title></atom:title>
+</atom:entry>'
+  
+    #Creates a new Folder instance.  Requires a valid GData4Ruby#Service object.
+    def initialize(service, attributes = {})
+      super(service, attributes)
+      @xml = FOLDER_XML
+    end
+
+    public
+    #Loads the Calendar with returned data from Google Calendar feed.  Returns true if successful.
+    def load(string)
+      super(string)
+      xml = REXML::Document.new(string)
+      xml.root.elements.each(){}.map do |ele|
+#        case ele.name
+#          
+#        end
+      end
+      
+      @folder_feed = @id
+      return true
+    end
+    
+    #Returns a list of sub folders that this folder contains.
+    def sub_folders
+      ret = service.send_request(GData4Ruby::Request.new(:get, @content_uri+"/-/folder?showfolders=true"))
+      folders = []
+      REXML::Document.new(ret.body).root.elements.each("entry"){}.map do |entry|
+        entry = GData4Ruby::Utils::add_namespaces(entry)
+        folder = Folder.new(service)
+        puts entry.to_s if service.debug
+        folder.load("<?xml version='1.0' encoding='UTF-8'?>#{entry.to_s}")
+        folders << folder
+      end
+      return folders
+    end
+    
+    #Returns a list of files in the folder
+    def files
+      return nil if @content_uri == nil
+      contents = []
+      ret = @service.send_request(GData4Ruby::Request.new(:get, @content_uri))
+      xml = REXML::Document.new(ret.body)
+      xml.root.elements.each('entry'){}.map do |ele|
+        ele = GData4Ruby::Utils::add_namespaces(ele)
+        obj = BaseObject.new(@service)
+        obj.load(ele.to_s)
+        case obj.type
+          when 'document'
+            doc = Document.new(@service)
+          when 'spreadsheet'
+            doc = Spreadsheet.new(@service)
+          when 'presentation'
+            doc = Presentation.new(service)
+        end
+        doc.load(ele.to_s)
+        contents << doc
+      end
+      return contents
+    end
+    
+    #Helper function limit queries to Folders.  See BaseObject#find for syntax.  Type is not required and assumed to be 'document'.
+    def self.find(service, query, args = {})      
+      raise ArgumentError if not query.is_a? Hash and not query.is_a? String
+      ret = query.is_a?(String) ? [] : nil
+      service.folders.each do |f|
+        if (query.is_a? Hash and ((query[:id] and f.id == query[:id]) or (query[:query] and f.title.include? query[:query])))
+          return f
+        end
+        if (query.is_a? String and f.title.include? query)
+          ret << f
+        end
+      end
+      return ret
+    end
+    
+    #A reference to the parent folder.  If there is no parent folder, nil is returned.
+    def parent
+      return nil if @parent_uri == nil
+      ret = @service.send_request(GData4Ruby::Request.new(:get, @parent_uri))
+      folder = nil
+      puts ret.body if @service.debug
+      folder = Folder.new(@service)
+      folder.load(ret.body)
+      return folder
+    end
+  end
+end

data/lib/gdocs4ruby/presentation.rb

@@ -0,0 +1,83 @@
+# 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 GDocs4Ruby
+  #The Presentation class represents a Google Presentation.  Also check out Document and BaseObject, the superclass of Presentation.
+  #=Usage
+  #All usages assume you've already authenticated with the service, and have a service object called
+  #@service.  
+  #1. Create a new Presentation
+  #    p = Presentation.new(@service)
+  #    p.title = 'Test Presentation'
+  #    p.local_file = '/path/to/some/spreadsheet.ppt'
+  #    p.save
+  #
+  #2. Deleting a Presentation
+  #    p = Presentation.find(@service, {:id => @doc_id})
+  #    p.delete
+  #
+  #3. Finding an existing Presentation by id
+  #    p = Presentation.find(@service, {:id => @doc_id})
+  #
+  #4. Full Text Query
+  #    p = Presentation.find(@service, 'content text')
+  #
+  #   or
+  #
+  #    p = Presentation.find(@service, {:query => 'content text'})
+  #
+  #5. Finding an Existing Spreadsheet by Title
+  #    p = Presentation.find(@service, nil, {'title' => 'Test Presentation'})
+  #
+  #6. Retrieving an Export
+  #    p = Presentation.find(@service, {:id => @doc_id})
+  #    p.download_to_file('pdf', '/path/to/save/location.pdf')
+  
+  class Presentation < Document
+    DOCUMENT_XML = '<?xml version="1.0" encoding="UTF-8"?>
+<atom:entry xmlns:atom="http://www.w3.org/2005/Atom">
+  <atom:category scheme="http://schemas.google.com/g/2005#kind"
+      term="http://schemas.google.com/docs/2007#spreadsheet" label="presentation"/>
+  <atom:title></atom:title>
+</atom:entry>'
+    DOWNLOAD_TYPES = ['pdf', 'png', 'ppt', 'swf', 'txt']
+    EXPORT_URI = 'http://docs.google.com/feeds/download/presentations/Export'
+    
+    #Helper function limit queries to Presentations.  See BaseObject::find for syntax.  Type is not required and assumed to be 'presentation'.
+    def self.find(service, query, args = {})
+      BaseObject::find(service, query, 'presentation', args)
+    end
+    
+    #Creates a new Presentation instance.  Requires a valid Service object.
+    def initialize(service, attributes = {})
+      super(service, attributes)
+      @xml = DOCUMENT_XML
+    end
+    
+    #Retrieves an export of the Presentation.  The parameter +type+ must be one of the DOWNLOAD_TYPES
+    def get_content(type)
+      if !@exists
+        raise DocumentDoesntExist
+      end
+      if not DOWNLOAD_TYPES.include? type
+        raise ArgumentError
+      end
+      ret = service.send_request(GData4Ruby::Request.new(:get, EXPORT_URI, nil, nil, {"docID" => @id,"exportFormat" => type}))
+      ret.body
+    end
+  end
+end

data/lib/gdocs4ruby/service.rb

@@ -0,0 +1,105 @@
+# 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 'gdocs4ruby/base' 
+require 'gdocs4ruby/base_object'
+require 'gdocs4ruby/folder'
+require 'gdocs4ruby/document'
+require 'gdocs4ruby/spreadsheet'
+require 'gdocs4ruby/presentation'
+
+module GDocs4Ruby
+
+DOCUMENT_LIST_FEED = "https://docs.google.com/feeds/documents/private/full"
+FOLDER_LIST_FEED = "http://docs.google.com/feeds/documents/private/full/-/folder?showfolders=true"
+
+  #The service class is the main handler for all direct interactions with the 
+  #Google Documents API.  A service represents a single user account.  Each user
+  #account can have multiple documents and folders.
+  #=Usage
+  #
+  #1. Authenticate
+  #    service = Service.new
+  #    service.authenticate("user@gmail.com", "password")
+  #
+  #2. Get Document List
+  #    documents = service.files
+  #
+  #3. Get Folder List
+  #    folders = serivce.folders
+  #
+  class Service < GData4Ruby::Service    
+    #Accepts an optional attributes hash for initialization values
+    def initialize(attributes = {})
+      super(attributes)
+    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='writely')
+      super(username, password, service)
+    end
+    
+    #Helper function to reauthenticate to a new Google service without having to re-set credentials.
+    def reauthenticate(service='writely')
+      authenticate(@account, @password, service)
+    end
+    
+    #Returns an array of Folder objects for each folder associated with 
+    #the authenticated account.
+    def folders
+      if not @auth_token
+         raise NotAuthenticated
+      end
+      ret = send_request(GData4Ruby::Request.new(:get, FOLDER_LIST_FEED))
+      folders = []
+      REXML::Document.new(ret.body).root.elements.each("entry"){}.map do |entry|
+        entry = GData4Ruby::Utils::add_namespaces(entry)
+        folder = Folder.new(self)
+        puts entry.to_s if debug
+        folder.load("<?xml version='1.0' encoding='UTF-8'?>#{entry.to_s}")
+        folders << folder
+      end
+      return folders
+    end
+    
+    #Returns an array of objects for each document in the account.  Note that this 
+    #method will return all documents for the account, including documents contained in
+    #subfolders.
+    def files
+      contents = []
+      ret = send_request(GData4Ruby::Request.new(:get, DOCUMENT_LIST_FEED))
+      xml = REXML::Document.new(ret.body)
+      xml.root.elements.each('entry'){}.map do |ele|
+        ele = GData4Ruby::Utils::add_namespaces(ele)
+        obj = BaseObject.new(self)
+        obj.load(ele.to_s)
+        case obj.type
+          when 'document'
+            doc = Document.new(self)
+          when 'spreadsheet'
+            doc = Spreadsheet.new(self)
+          when 'presentation'
+            doc = Presentation.new(self)
+        end
+        doc.load(ele.to_s)
+        contents << doc
+      end
+      return contents
+    end
+  end
+end

data/lib/gdocs4ruby/spreadsheet.rb

@@ -0,0 +1,85 @@
+# 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 GDocs4Ruby
+  #The Spreadsheet class represents a Google Spreadsheet.  Also check out Document and BaseObject, the superclass of Spreadsheet.
+  #=Usage
+  #All usages assume you've already authenticated with the service, and have a service object called
+  #@service.  
+  #1. Create a new Spreadsheet
+  #    s = Spreadsheet.new(@service)
+  #    s.title = 'Test Spreadsheet'
+  #    s.local_file = '/path/to/some/spreadsheet.xls'
+  #    s.save
+  #
+  #2. Deleting a Spreadsheet
+  #    s = Spreadsheet.find(@service, {:id => @doc_id})
+  #    s.delete
+  #
+  #3. Finding an existing Spreadsheet by id
+  #    s = Spreadsheet.find(@service, {:id => @doc_id})
+  #
+  #4. Full Text Query
+  #    s = Spreadsheet.find(@service, 'content text')
+  #
+  #   or
+  #
+  #    s = Spreadsheet.find(@service, {:query => 'content text'})
+  #
+  #5. Finding an Existing Spreadsheet by Title
+  #    s = Spreadsheet.find(@service, nil, {'title' => 'Test Spreadsheet'})
+  #
+  #6. Retrieving an Export
+  #    s = Spreadsheet.find(@service, {:id => @doc_id})
+  #    s.download_to_file('pdf', '/path/to/save/location.pdf')
+  
+  class Spreadsheet < Document
+    DOCUMENT_XML = '<?xml version="1.0" encoding="UTF-8"?>
+<atom:entry xmlns:atom="http://www.w3.org/2005/Atom">
+  <atom:category scheme="http://schemas.google.com/g/2005#kind"
+      term="http://schemas.google.com/docs/2007#spreadsheet" label="spreadsheet"/>
+  <atom:title></atom:title>
+</atom:entry>'
+    DOWNLOAD_TYPES = ['xls', 'csv', 'pdf', 'ods', 'tsv', 'html']
+    EXPORT_URI = 'http://spreadsheets.google.com/feeds/download/spreadsheets/Export'
+    
+    #Helper function limit queries to Spreadsheets.  See BaseObject::find for syntax.  Type is not required and assumed to be 'spreadsheet'.
+    def self.find(service, query, args = {})
+      BaseObject::find(service, query, 'spreadsheet', args)
+    end
+    
+    #Creates a new Spreadsheet instance.  Requires a valid Service object.
+    def initialize(service, attributes = {})
+      super(service, attributes)
+      @xml = DOCUMENT_XML
+    end
+    
+    #Retrieves an export of the Spreadsheet.  The parameter +type+ must be one of the DOWNLOAD_TYPES.
+    def get_content(type)
+      if !@exists
+        raise DocumentDoesntExist
+      end
+      if not DOWNLOAD_TYPES.include? type
+        raise ArgumentError
+      end
+      service.reauthenticate('wise')
+      ret = service.send_request(GData4Ruby::Request.new(:get, EXPORT_URI, nil, nil, {"key" => @id.gsub(/\w.*:/, ""),"exportFormat" => type}))
+      service.reauthenticate()
+      ret.body
+    end
+  end
+end

data/lib/gdocs4ruby.rb

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

data/test/unit.rb

@@ -0,0 +1,3 @@
+if __FILE__ == $0
+  # TODO Generated stub
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: gdocs4ruby
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Mike Reich
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-12 00:00:00 +11:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: gdata4ruby
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.0
+    version: 
+description: GDocs4Ruby is a full featured wrapper for version 2.0 of the Google Documents API (aka DocList).  GDocs4Ruby provides the ability to create, update and delete google documents, metadata and content.  The gem also includes support for folders, modifying permissions for documents via ACL feeds, and much more.
+email: mike@seabourneconsulting.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- CHANGELOG
+- lib/gdocs4ruby.rb
+- lib/gdocs4ruby/service.rb
+- lib/gdocs4ruby/folder.rb
+- lib/gdocs4ruby/document.rb
+- lib/gdocs4ruby/base_object.rb
+- lib/gdocs4ruby/spreadsheet.rb
+- lib/gdocs4ruby/presentation.rb
+has_rdoc: true
+homepage: http://gdocs4ruby.rubyforge.org/
+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: gdocs4ruby
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A full featured wrapper for interacting with the Google Docs API
+test_files: 
+- test/unit.rb