gdata2 0.1

data/CREDITS

@@ -0,0 +1,3 @@
+
+This code began as a project by Jérôme Bousquié as a google code project:
+http://code.google.com/p/gdatav2rubyclientlib/.

data/Manifest.txt

@@ -0,0 +1,15 @@
+CREDITS
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+TODO
+bin/config.yml
+bin/sync-google-apps
+gdata2.gemspec
+lib/gdata.rb
+lib/gdata/apps.rb
+lib/gdata/apps/email.rb
+lib/gdata/apps/provisioning.rb
+lib/gdata/messages.rb
+scripts/test.rb

data/README.txt

@@ -0,0 +1,70 @@
+= gdata2
+
+== DESCRIPTION:
+
+gdata2 is a Ruby wrapper around the Google Data API's.
+
+== FEATURES:
+
+* Provides simple to use ruby-like api to Google Data API's.
+
+== INSTALL:
+
+=== Ruby Gem:
+
+	sudo gem install gdata2
+
+=== Manual Download:
+
+Install ruby-net-ldap gem
+Install sequel gem
+Install sqlite3-ruby gem
+Download the latest release from <URL>
+
+=== Git:
+
+You can check out the git repository at http://github.com/<URL>
+
+== TODO:
+
+#Unfinished
+* Document the configuration yml for gapps-provision
+* Set timestamps on the resulting database
+* Un neuter the creation queue
+* Un neuter the alteration queue
+* enter code for the creation of admin users from the gapps-provision
+file?
+* inserts into the google alias table appears to not check and see if
+they already exist
+
+Adding more Google Data apis to the bundle.
+# Apps APIs
+* Provisioning
+* Email Settings
+* Calendar Data
+* Reporting
+# Data APIs
+* Contacts Data
+* Documents List Data
+* Spreadsheets Data'
+
+== SYNOPSIS:
+
+TODO: write new
+
+== LICENSE:
+
+ Copyright 2008-2009 Jérôme Bousquié
+ Copyright 2009      Montana State University
+
+Licensed under the Apache License, 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.apache.org/licenses/LICENSE-2.0
+
+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.
+See the License for the specific language governing permissions and
+limitations under the License.

data/Rakefile

@@ -0,0 +1,62 @@
+# -*- ruby -*-
+ 
+require 'rubygems'
+require 'hoe'
+require "spec/rake/spectask"
+require './lib/gdata'
+ 
+class Hoe
+  def extra_deps; @extra_deps.reject { |x| Array(x).first == "hoe" } end
+end # copied from the Rakefile of the sup project
+ 
+Hoe.new('gdata2', "0.1") do |p|
+  p.rubyforge_name = 'gdata2'
+  p.author = 'Ivan R. Judson'
+  p.email = 'ivan.judson@montana.edu'
+  p.summary = 'Ruby Wrapper for the Google Data APIs'
+  p.description = p.paragraphs_of('README.txt', 2..3).join("\n\n")
+  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.remote_rdoc_dir = ''
+end
+ 
+ 
+RDOC_OPTS = [
+  '--quiet',
+  '--title', 'gdata2 APIs',
+  '--main', 'README.txt',
+  '--charset', 'utf-8',
+  '--inline-source',
+  '--tab-width', '2',
+  '--line-numbers',
+]
+ 
+Rake::RDocTask.new do |rdoc|
+    rdoc.rdoc_dir = 'doc/'
+    rdoc.options = RDOC_OPTS
+    rdoc.main = "README.txt"
+    rdoc.rdoc_files.add [
+      'LICENSE.txt',
+      'README.txt',
+      'History.txt',
+      'lib/**/*.rb'
+    ]
+end
+ 
+# desc "Run all specs"
+# Spec::Rake::SpecTask.new do |t|
+#   t.spec_files = FileList["spec/**/*_spec.rb"]
+#   t.spec_opts = ["--options", "spec/spec.opts"]
+# end
+#  
+# desc "Run all specs and get coverage statistics"
+# Spec::Rake::SpecTask.new('spec:rcov') do |t|
+#   t.spec_files = FileList["spec/**/*_spec.rb"]
+#   t.rcov = true
+#   t.spec_opts = ["--options", "spec/spec.opts"]
+# end
+#  
+# Rake::Task[:default].prerequisites.clear
+# task :default => :spec
+ 
+# vim: syntax=Ruby

data/TODO

@@ -0,0 +1,12 @@
+TODO List
+===========================
+Adding more Google Data apis to the bundle.
+# Apps APIs
+* Provisioning
+* Email Settings
+* Calendar Data
+* Reporting
+# Data APIs
+* Contacts Data
+* Documents List Data
+* Spreadsheets Data'

data/gdata2.gemspec

@@ -0,0 +1,34 @@
+Gem::Specification.new do |s|
+  s.name = %q{gdata2}
+  s.version = "0.1"
+  s.authors = ["Jérôme Bousquié", "Ivan R. Judson"]
+  s.email = "ivan.judson@montana.edu"
+  s.date = %q{2009-02-20}
+  s.homepage = ""
+  s.summary = "Ruby wrapper for Google Data API's"
+  s.description = "gdata2 is a ruby wrapper for the google data apis"
+
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.txt"]
+  s.rdoc_options = ["--main", "README.txt"]
+  s.files = ["CREDITS", "History.txt", "Manifest.txt", "README.txt", 
+             "Rakefile", "TODO", "gdata2.gemspec", "lib/gdata.rb", 
+             "lib/gdata/apps/provisioning.rb"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = "gdata2"
+  s.rubygems_version = "1.3.1"
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<hoe>, [">= 1.8.3"])
+    else
+      s.add_dependency(%q<hoe>, [">= 1.8.3"])
+    end
+  else
+    s.add_dependency(%q<hoe>, [">= 1.8.3"])
+  end
+end

data/lib/gdata.rb

@@ -0,0 +1,58 @@
+$:.unshift(File.expand_path(File.dirname(__FILE__))) unless
+$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+module GData #:nodoc:
+  require 'net/https'
+  require 'cgi'
+
+  class Connection
+    attr_reader  :http_connection
+
+    # Establishes SSL connection to Google host
+    def initialize(host, port, proxy=nil, proxy_port=nil, proxy_user=nil, proxy_passwd=nil)
+      conn = Net::HTTP.new(host, port, proxy, proxy_port, proxy_user, proxy_passwd)
+      conn.use_ssl = true
+      conn.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      conn.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      store = OpenSSL::X509::Store.new
+      store.set_default_paths
+      conn.cert_store = store
+      conn.start
+      @http_connection = conn
+    end
+
+    # Performs the http request and returns the http response
+    def perform(method, path='', body=nil, header=nil)
+      backoff_factor = 2
+      resp = nil
+      while resp.nil?
+        begin
+          req = Net::HTTPGenericRequest.new(method, ! body.nil?, true, path)
+          req['Content-Type'] = header['Content-Type'] if header['Content-Type']
+          req['Authorization'] = header['Authorization'] if header['Authorization']
+          req['Content-length'] = body.length.to_s if body
+          resp = @http_connection.request(req, body)
+        rescue Timeout::Error
+          retry
+        rescue GData::GDataError => e
+          if e.code == "503"
+            resp = nil
+            sleep(backoff_factor)
+            backoff_factor *= backoff_factor
+          else
+            return e
+          end
+        rescue Errno::EPIPE
+          retry
+        rescue EOFError
+        end
+      end
+
+      return resp
+    end
+  end
+
+  class GDataError < RuntimeError
+    attr_accessor :code, :input, :reason
+  end
+end

data/lib/gdata/apps/provisioning.rb

@@ -0,0 +1,437 @@
+$:.unshift(File.expand_path(File.dirname(__FILE__))) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'messages'
+
+module GData #:nodoc:
+  module Apps #:nodoc:
+    # =Administrative object for accessing your domain
+    # Examples
+    #
+    #       adminuser = "root@mydomain.com"
+    #       password  = "PaSsWo4d!"
+    #       gapp = GApps.new('root@mydomain.com','PaSsWoRd')
+    #       myapps = Provisioning.new(gapp)
+    #       (see examples in  ProvisioningApi.new documentation for handling proxies)
+    #
+    #       new_user = myapps.create_user("jsmith", "john", "smith", "secret", nil, "2048")
+    #       puts new_user.family_name
+    #       puts new_user.given_name
+    #
+    # Want to update a user ?
+    #
+    #       user = myapps.retrieve_user('jsmith')
+    #       user_updated = myapps.update_user(user.username, user.given_name, user.family_name, nil, nil, "true")
+    #
+    # Want to add an alias or nickname ?
+    #
+    #       new_nickname = myapps.create_nickname("jsmith", "john.smith")
+    #
+    # Want to handle errors ?
+    #
+    #       begin
+    #               user = myapps.retrieve_user('noone')
+    #               puts "givenName : "+user.given_name, "familyName : "+user.family_name, "username : "+user.username"
+    #               puts "admin ? : "+user.admin
+    #       rescue GDataError => e
+    #               puts "errorcode = " +e.code, "input : "+e.input, "reason : "+e.reason
+    #       end
+    #
+    # Group ?
+    #
+    #       new_list = myapps.create_group("sale-dep")
+    #       new_address = myapps.add_to_group("sale-dep", "bibi@ruby-forge.org")
+    #
+
+    class Provisioning
+
+      @@google_host = 'apps-apis.google.com'
+
+      # Creates a new Provisioning object
+      #
+      #  apps:  Google Apps Object (GData::GApps)
+      #
+      #
+      # Examples :
+      #       standard : no proxy
+      #       gapp = GApps.new('root@mydomain.com','PaSsWoRd')
+      #       myapps = Provisioning.new(gapp)
+      #       proxy :
+      #       gapp = GApps.new('root@mydomain.com','PaSsWoRd','domain.proxy.com',8080)
+      #       myapps = Provisioning.new(gapp)
+      #       authenticated proxy :
+      #       gapp = GApps.new('root@mydomain.com','PaSsWoRd','domain.proxy.com',8080,'foo','bAr')
+      #       myapps = ProvisioningApi.new(gapp)
+      #
+      def initialize(apps)
+        @apps = apps
+        setup_actions()
+      end
+
+      # Creates an account in your domain, returns a UserEntry instance
+      #       params :
+      #                       username, given_name, family_name and password are required
+      #                       passwd_hash_function (optional) : nil (default) or "SHA-1"
+      #                       quota (optional) : nil (default) or integer for limit in MB
+      #       ex :
+      #                       gapp = GApps.new('root@mydomain.com','PaSsWoRd')
+      #                       myapps = ProvisioningApi.new(gapp)
+      #                       user = myapps.create('jsmith', 'John', 'Smith', 'p455wD')
+      #
+      # By default, a new user must change his password at first login. Please use update_user if you want to change this just after the creation.
+      def create_user(username, given_name, family_name, password, passwd_hash_function=nil, quota=nil)
+        msg = ProvisioningMessage.new
+        msg.about_login(username,password,passwd_hash_function,"false","false", "true")
+        msg.about_name(family_name, given_name)
+        msg.about_quota(quota.to_s) if quota
+        response  = @apps.request(:user_create,nil, msg.to_s)
+        #user_entry = UserEntry.new(response.elements["entry"])
+      end
+
+
+      # Returns a UserEntry instance from a username
+      #       ex :
+      #                       gapp = GApps.new('root@mydomain.com','PaSsWoRd')
+      #                       myapps = ProvisioningApi.new(gapp)
+      #                       user = myapps.retrieve_user('jsmith')
+      #                       puts "givenName : "+user.given_name
+      #                       puts "familyName : "+user.family_name
+      def retrieve_user(username)
+        xml_response = @apps.request(:user_retrieve, username)
+        if xml_response.respond_to? :elements
+          user_entry = UserEntry.new(xml_response.elements["entry"])
+        end
+      end
+
+      # Returns a UserEntry array populated with all the users in the domain. May take a while depending on the number of users in your domain.
+      #       ex :
+      #                       gapp = GApps.new('root@mydomain.com','PaSsWoRd')
+      #                       myapps = ProvisioningApi.new(gapp)
+      #                       list= myapps.retrieve_all_users
+      #                       list.each{ |user| puts user.username}
+      #                       puts 'nb users : ',list.size
+      def retrieve_all_users
+        response = @apps.request(:user_retrieve_all)
+        user_feed = Feed.new(response.elements["feed"],  UserEntry)
+        user_feed = add_next_feeds(user_feed, response, UserEntry)
+      end
+
+      # Returns a UserEntry array populated with 100 users, starting from a username
+      #       ex :
+      #                       gapp = GApps.new('root@mydomain.com','PaSsWoRd')
+      #                       myapps = ProvisioningApi.new(gapp)
+      #                       list= myapps.retrieve_page_of_users("jsmtih")
+      #                       list.each{ |user| puts user.username}
+      def retrieve_page_of_users(start_username)
+        param='?startUsername='+start_username
+        response = @apps.request(:user_retrieve_all,param)
+        user_feed = Feed.new(response.elements["feed"],  UserEntry)
+      end
+
+      # Updates an account in your domain, returns a UserEntry instance
+      #       params :
+      #                       username is required and can't be updated.
+      #                       given_name and family_name are required, may be updated.
+      #                       if set to nil, every other parameter won't update the attribute.
+      #                               passwd_hash_function :  string "SHA-1" or nil (default)
+      #                               admin :  string "true" or string "false" or nil (no boolean : true or false).
+      #                               suspended :  string "true" or string "false" or nil (no boolean : true or false)
+      #                               change_passwd :  string "true" or string "false" or nil (no boolean : true or false)
+      #                               quota : limit en MB, ex :  string "2048"
+      #               ex :
+      #                       gapp = GApps.new('root@mydomain.com','PaSsWoRd')
+      #                       myapps = ProvisioningApi.new(gapp)
+      #                       user = myapps.update('jsmith', 'John', 'Smith', nil, nil, "true", nil, "true", nil)
+      #                       puts user.admin         => "true"
+      def update_user(username, given_name, family_name, password=nil, passwd_hash_function=nil, admin=nil, suspended=nil, changepasswd=nil, quota=nil)
+        msg = ProvisioningMessage.new
+        msg.about_login(username,password,passwd_hash_function,admin,suspended, changepasswd)
+        msg.about_name(family_name, given_name)
+        msg.about_quota(quota) if quota
+        response  = @apps.request(:user_update,username, msg.to_s)
+        #user_entry = UserEntry.new(response.elements["entry"])
+      end
+
+      # Deletes an account in your domain
+      #               ex :
+      #                       gapp = GApps.new('root@mydomain.com','PaSsWoRd')
+      #                       myapps = ProvisioningApi.new(gapp)
+      #                       myapps.delete('jsmith')
+      def delete_user(username)
+        response  = @apps.request(:user_delete,username)
+      end
+
+      # Creates a nickname for the username in your domain and returns a NicknameEntry instance
+      #               gapp = GApps.new('root@mydomain.com','PaSsWoRd')
+      #               myapps = ProvisioningApi.new(gapp)
+      #               mynewnick = myapps.create_nickname('jsmith', 'john.smith')
+      def create_nickname(username, nickname)
+        msg = ProvisioningMessage.new
+        msg.about_login(username)
+        msg.about_nickname(nickname)
+        response  = @apps.request(:nickname_create,nil, msg.to_s)
+        #nickname_entry = NicknameEntry.new(response.elements["entry"])
+      end
+
+      # Returns a NicknameEntry instance from a nickname
+      #       ex :
+      #                       gapp = GApps.new('root@mydomain.com','PaSsWoRd')
+      #                       myapps = ProvisioningApi.new(gapp)
+      #                       nickname = myapps.retrieve_nickname('jsmith')
+      #                       puts "login : "+nickname.login
+      def retrieve_nickname(nickname)
+        xml_response = @apps.request(:nickname_retrieve, nickname)
+        nickname_entry = NicknameEntry.new(xml_response.elements["entry"])
+      end
+
+      # Returns a NicknameEntry array from a username
+      #       ex : lists jsmith's nicknames
+      #               gapp = GApps.new('root@mydomain.com','PaSsWoRd')
+      #               myapps = ProvisioningApi.new(gapp)
+      #               mynicks = myapps.retrieve('jsmith')
+      #               mynicks.each {|nick| puts nick.nickname }
+      def retrieve_nicknames(username)
+        xml_response = @apps.request(:nickname_retrieve_all_for_user, username, @headers)
+        
+        nicknames_feed = Feed.new(xml_response.elements["feed"],  NicknameEntry)
+        nicknames_feed = add_next_feeds(nicknames_feed, xml_response, NicknameEntry)
+      end
+
+      # Returns a NicknameEntry array for the whole domain. May take a while depending on the number of users in your domain.
+      #       gapp = GApps.new('root@mydomain.com','PaSsWoRd')
+      #       myapps = ProvisioningApi.new(gapp)
+      #       allnicks = myapps.retrieve_all_nicknames
+      #       allnicks.each {|nick| puts nick.nickname }
+      def retrieve_all_nicknames
+        xml_response = @apps.request(:nickname_retrieve_all_in_domain, nil, @headers)
+        nicknames_feed = Feed.new(xml_response.elements["feed"],  NicknameEntry)
+        nicknames_feed = add_next_feeds(nicknames_feed, xml_response, NicknameEntry)
+      end
+
+      # Deletes the nickname  in your domain
+      #               gapp = GApps.new('root@mydomain.com','PaSsWoRd')
+      #               myapps = ProvisioningApi.new(gapp)
+      #               myapps.delete_nickname('john.smith')
+      def delete_nickname(nickname)
+        response  = @apps.request(:nickname_delete,nickname)
+      end
+
+      # Returns a NicknameEntry array populated with 100 nicknames, starting from a nickname
+      #       ex :
+      #              gapp = GApps.new('root@mydomain.com','PaSsWoRd')
+      #              myapps = ProvisioningApi.new(gapp)
+      #              list= myapps.retrieve_page_of_nicknames("joe")
+      #              list.each{ |nick| puts nick.login}
+      def retrieve_page_of_nicknames(start_nickname)
+        param='?startNickname='+start_nickname
+        xml_response = @apps.request(:nickname_retrieve_all_in_domain, param, @headers)
+        nicknames_feed = Feed.new(xml_response.elements["feed"],  NicknameEntry)
+      end
+
+      def create_group
+        raise NotImplementedError
+      end
+
+      def update_group
+        raise NotImplementedError
+      end
+
+      def retrieve_group
+        raise NotImplementedError
+      end
+
+      def delete_group
+        raise NotImplementedError
+      end
+
+      def add_member_to_group
+        raise NotImplementedError
+      end
+
+      def retrieve_members_of_group
+        raise NotImplementedError
+      end
+
+      def remove_member_from_group
+        raise NotImplementedError
+      end
+
+      def add_owner_to_group
+        raise NotImplementedError
+      end
+
+      def retrieve_owner_of_group
+        raise NotImplementedError
+      end
+
+      def remove_owner_from_group
+        raise NotImplementedError
+      end
+
+      # private methods
+      private #:nodoc:
+
+      # Associates methods, http verbs and URL for REST access
+      def setup_actions
+        domain = @apps.domain
+        path_user = '/a/feeds/'+domain+'/user/2.0'
+        path_nickname = '/a/feeds/'+domain+'/nickname/2.0'
+        path_email_list = '/a/feeds/'+domain+'/emailList/2.0'
+        path_group = '/a/feeds/group/2.0/'+domain
+
+        @apps.register_action(:domain_login, {:method => 'POST', :path => '/accounts/ClientLogin' })
+        @apps.register_action(:user_create, { :method => 'POST', :path => path_user })
+        @apps.register_action(:user_retrieve, { :method => 'GET', :path => path_user+'/' })
+        @apps.register_action(:user_retrieve_all, { :method => 'GET', :path => path_user })
+        @apps.register_action(:user_update, { :method => 'PUT', :path => path_user +'/' })
+        @apps.register_action(:user_delete, { :method => 'DELETE', :path => path_user +'/' })
+        @apps.register_action(:nickname_create, { :method => 'POST', :path =>path_nickname })
+        @apps.register_action(:nickname_retrieve, { :method => 'GET', :path =>path_nickname+'/' })
+        @apps.register_action(:nickname_retrieve_all_for_user, { :method => 'GET', :path =>path_nickname+'?username=' })
+        @apps.register_action(:nickname_retrieve_all_in_domain, { :method => 'GET', :path =>path_nickname })
+        @apps.register_action(:nickname_delete, { :method => 'DELETE', :path =>path_nickname+'/' })
+        @apps.register_action(:group_create, { :method => 'POST', :path => path_group })
+        @apps.register_action(:group_update, { :method => 'PUT', :path => path_group })
+        @apps.register_action(:group_retrieve, { :method => 'GET', :path => path_group })
+        @apps.register_action(:group_delete, { :method => 'DELETE', :path => path_group })
+
+        # special action "next" for linked feed results. :path will be affected with URL received in a link tag.
+        @apps.register_action(:next,  {:method => 'GET', :path =>'' })
+      end
+
+      # Completes the feed by following et requesting the URL links
+      def add_next_feeds(current_feed, xml_content, element_class)
+        XPath.each(xml_content, 'feed/link') { |link|
+          if link.attributes.has_key?("rel") && link.attributes["rel"] == "next"
+            next_response = @apps.request(:next, link.attributes["href"])
+            current_feed.concat(Feed.new(next_response.elements["feed"], element_class))
+            current_feed = add_next_feeds(current_feed, next_response, element_class)
+          end
+        }
+        return current_feed
+      end
+    end
+
+
+    # UserEntry object.
+    #
+    # Handles API responses relative to a user
+    #
+    # Attributes :
+    #       username : string
+    #       given_name : string
+    #       family_name : string
+    #       suspended : string "true" or string "false"
+    #       ip_whitelisted : string "true" or string "false"
+    #       admin : string "true" or string "false"
+    #       change_password_at_next_login : string "true" or string "false"
+    #       agreed_to_terms : string "true" or string "false"
+    #       quota_limit : string (value in MB)
+    class UserEntry
+      attr_reader :given_name, :family_name, :username, :suspended, :ip_whitelisted, :admin, :change_password_at_next_login, :agreed_to_terms, :quota_limit
+
+      # UserEntry constructor. Needs a REXML::Element <entry> as parameter
+      def initialize(entry) #:nodoc:
+        @family_name = entry.elements["apps:name"].attributes["familyName"]
+        @given_name = entry.elements["apps:name"].attributes["givenName"]
+        @username = entry.elements["apps:login"].attributes["userName"]
+        @suspended = entry.elements["apps:login"].attributes["suspended"]
+        @ip_whitelisted = entry.elements["apps:login"].attributes["ipWhitelisted"]
+        @admin = entry.elements["apps:login"].attributes["admin"]
+        @change_password_at_next_login = entry.elements["apps:login"].attributes["changePasswordAtNextLogin"]
+        @agreed_to_terms = entry.elements["apps:login"].attributes["agreedToTerms"]
+        @quota_limit = entry.elements["apps:quota"].attributes["limit"]
+      end
+
+      def to_s
+        outstr = "#<#{self.class}:0x#{self.object_id.to_s(16)}>\n"
+        instance_variables.sort.each do |v|
+          outstr += "\t#{v[1,v.length-1]} : #{instance_variable_get(v).to_s}\n"
+        end
+        outstr
+      end
+    end
+
+    # NicknameEntry object.
+    #
+    # Handles API responses relative to a nickname
+    #
+    # Attributes :
+    #       login : string
+    #       nickname : string
+    class NicknameEntry
+      attr_reader :login, :nickname
+
+      # NicknameEntry constructor. Needs a REXML::Element <entry> as parameter
+      def initialize(entry) #:nodoc:
+        @login = entry.elements["apps:login"].attributes["userName"]
+        if entry.elements["apps:nickname"].nil?
+          # IRJ Some call is failing 10 minutes into a run, I'll debug
+          @nickname = nil
+        else
+          @nickname = entry.elements["apps:nickname"].attributes["name"]
+        end
+      end
+
+      def to_s
+        outstr = "#<#{self.class}:0x#{self.object_id.to_s(16)}>\n"
+        outstr += "\t#{@login} : #{@nickname}"
+      end
+    end
+
+    # UserFeed object : Array populated with Element_class objects (UserEntry, NicknameEntry, EmailListEntry or EmailListRecipientEntry)
+    class Feed < Array #:nodoc:
+
+      # UserFeed constructor. Populates an array with Element_class objects. Each object is an xml <entry> parsed from the REXML::Element <feed>.
+      # Ex : user_feed = Feed.new(xml_feed, UserEntry)
+      #               nickname_feed = Feed.new(xml_feed, NicknameEntry)
+      def initialize(xml_feed, element_class)
+        if xml_feed.respond_to? :elements
+          xml_feed.elements.each("entry"){ |entry| self << element_class.new(entry) }
+        end
+      end
+    end
+
+    class ProvisioningMessage < GData::RequestMessage #:nodoc:
+      def initialize
+        super
+        self.elements["atom:entry"].add_element "atom:category", {"scheme" => "http://schemas.google.com/g/2005#kind"}
+      end
+
+      # adds <apps:login> element in the message body.
+      # warning :  if valued admin, suspended, or change_passwd_at_next_login must be the STRINGS "true" or "false", not the boolean true or false
+      # when needed to construct the message, should always been used before other "about_" methods so that the category tag can be overwritten
+      # only values permitted for hash_function_function_name : "SHA-1" or nil
+      def about_login(user_name, passwd=nil, hash_function_name=nil, admin=nil, suspended=nil, change_passwd_at_next_login=nil)
+        self.elements["atom:entry/atom:category"].add_attribute("term", "http://schemas.google.com/apps/2006#user")
+        self.elements["atom:entry"].add_element "apps:login", {"userName" => user_name }
+        self.elements["atom:entry/apps:login"].add_attribute("password", passwd) if not passwd.nil?
+        self.elements["atom:entry/apps:login"].add_attribute("hashFunctionName", hash_function_name) if not hash_function_name.nil?
+        self.elements["atom:entry/apps:login"].add_attribute("admin", admin) if not admin.nil?
+        self.elements["atom:entry/apps:login"].add_attribute("suspended", suspended) if not suspended.nil?
+        self.elements["atom:entry/apps:login"].add_attribute("changePasswordAtNextLogin", change_passwd_at_next_login) if not change_passwd_at_next_login.nil?
+        return self
+      end
+
+      # adds <apps:quota> in the message body.
+      # limit in MB: integer
+      def about_quota(limit)
+        self.elements["atom:entry"].add_element "apps:quota", {"limit" => limit }
+        return self
+      end
+
+      # adds <apps:name> in the message body.
+      def about_name(family_name, given_name)
+        self.elements["atom:entry"].add_element "apps:name", {"familyName" => family_name, "givenName" => given_name }
+        return self
+      end
+
+      # adds <apps:nickname> in the message body.
+      def about_nickname(name)
+        self.elements["atom:entry/atom:category"].add_attribute("term", "http://schemas.google.com/apps/2006#nickname")
+        self.elements["atom:entry"].add_element "apps:nickname", {"name" => name}
+        return self
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: gdata2
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- "J\xC3\xA9r\xC3\xB4me Bousqui\xC3\xA9"
+- Ivan R. Judson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-20 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 8
+        - 3
+        version: 1.8.3
+  type: :development
+  version_requirements: *id001
+description: gdata2 is a ruby wrapper for the google data apis
+email: ivan.judson@montana.edu
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- CREDITS
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- TODO
+- gdata2.gemspec
+- lib/gdata.rb
+- lib/gdata/apps/provisioning.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: gdata2
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 2
+summary: Ruby wrapper for Google Data API's
+test_files: []
+