gdata-api 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+log
+pkg
+Manifest
+doc

data/Rakefile

@@ -0,0 +1,24 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/calendar_test.rb', 'test/contacts_test.rb']
+  t.verbose = true
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "gdata-api"
+    s.summary = "Google Data API expressed in Ruby"
+    s.email = "fkocherga@gmail.com"
+    s.homepage = "http://github.com/fkocherga/gdata-api"
+    s.authors = ["Fedor Kocherga"]
+    s.test_files = ['test/calendar_test.rb', 'test/contacts_test.rb']
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/gdata-api.gemspec

@@ -0,0 +1,50 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{gdata-api}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Fedor Kocherga"]
+  s.date = %q{2009-11-18}
+  s.email = %q{fkocherga@gmail.com}
+  s.files = [
+    ".gitignore",
+     "Rakefile",
+     "VERSION",
+     "gdata-api.gemspec",
+     "gdata.gemspec",
+     "lib/gdata/atom.rb",
+     "lib/gdata/calendar.rb",
+     "lib/gdata/contacts.rb",
+     "lib/gdata/data.rb",
+     "lib/gdata/request.rb",
+     "test/calendar_test.rb",
+     "test/contacts_test.rb",
+     "test/test_helper.rb",
+     "todo.txt"
+  ]
+  s.homepage = %q{http://github.com/fkocherga/gdata-api}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Google Data API expressed in Ruby}
+  s.test_files = [
+    "test/calendar_test.rb",
+     "test/contacts_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/gdata.gemspec

@@ -0,0 +1,49 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{gdata}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Fedor Kocherga"]
+  s.date = %q{2009-11-18}
+  s.email = %q{fkocherga@gmail.com}
+  s.files = [
+    ".gitignore",
+     "Rakefile",
+     "VERSION",
+     "gdata.gemspec",
+     "lib/gdata/atom.rb",
+     "lib/gdata/calendar.rb",
+     "lib/gdata/contacts.rb",
+     "lib/gdata/data.rb",
+     "lib/gdata/request.rb",
+     "test/calendar_test.rb",
+     "test/contacts_test.rb",
+     "test/test_helper.rb",
+     "todo.txt"
+  ]
+  s.homepage = %q{http://github.com/fkocherga/gdata}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Google Data API expressed in Ruby}
+  s.test_files = [
+    "test/calendar_test.rb",
+     "test/contacts_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/gdata/atom.rb

@@ -0,0 +1,172 @@
+require 'blankslate'
+
+module GData
+  module Atom
+    NAMESPACE = "xmlns"
+    Base = Class.new(Object.const_defined?(:Debugger) ? Object : BlankSlate) do
+      reveal(:send) unless Object.const_defined?(:Debugger)
+      
+      class << self
+        def fields
+          @fields ||=[]
+          if self.superclass.respond_to? :fields
+            return @fields + self.superclass.fields
+          else
+            return @fields
+          end
+        end
+          
+        def generate_field_accessor(field, path_and_klass = nil)
+          @fields ||= []
+          @fields << field
+          defining_class = self
+          define_method("#{field}_info".to_sym) do
+            path = field.to_s
+            klass = nil
+            case path_and_klass
+              when Hash:
+                path, klass = path_and_klass.to_a[0]
+              when String:
+                path = path_and_klass #no klass
+              when Class:
+                klass = path_and_klass
+            end
+            ns = defining_class.namespace
+            if !ns.empty?
+              is_attribute = '@' == path[0,1]
+              path = "#{ns}:#{path}" unless is_attribute
+            end
+            [path, klass]
+          end
+          
+          #get field value
+          define_method(field) do
+            path, klass = self.send("#{field}_info")
+            self.class.convert_to_value(@xml.xpath(path), klass)
+          end
+          
+#           #set field to value
+#           define_method("#{field}=".to_sym) do |value|
+#             path, var_name, klass = self.send("#{field}_info")
+#             instance_variable_set(var_name, value)
+#           end
+
+          #saves field value to xml
+          define_method("#{field}=".to_sym) do |value|
+            path, klass = self.send("#{field}_info")
+            is_attribute = '@' == path[0,1]
+            if is_attribute
+              attr_name = path[1..-1]
+              @xml[attr_name] = self.class.convert_to_xml(value)
+            else
+              node = @xml.xpath(path)[0]
+              node.content = self.class.convert_to_xml(value)
+            end
+          end
+          
+          define_method("add_#{field}".to_sym) do |value|
+            path,  klass = self.send("#{field}_info")
+            is_attribute = '@' == path[0,1]
+            node = nil
+            if !is_attribute
+              node = Nokogiri::XML::Node.new(path, @xml.document)
+              node = @xml.add_child(node)
+            end
+            self.send("#{field}=".to_sym, value) if value
+            klass.new(node) if node && klass && klass < Base
+          end
+
+          define_method("remove_#{field}".to_sym) do
+            path, klass = self.send("#{field}_info")
+            node = @xml.xpath(path).remove
+          end
+
+        end
+        
+        def elements(*elements)
+          unless Object.const_defined?(:Debugger)
+            reveal(:instance_variable_get) 
+            reveal(:instance_variable_set) 
+            reveal(:class)
+          end
+          elements.each do |field|
+            case field
+              when Symbol:
+                generate_field_accessor(field)
+              when Hash:
+                field.each {|f, path| generate_field_accessor(f, path)}
+            end
+          end
+        end
+        
+        def namespace
+          return @namespace if @namespace
+          @namespace = eval(self.name.gsub(/::[^:]+$/, "") + "::NAMESPACE")
+        end
+        
+        def atom_header
+          version = eval(self.name.gsub(/::[^:]+$/, "") + "::VERSION")
+          {"Content-Type" => "application/atom+xml", "GData-Version" => version}
+        end
+        
+        
+        def convert_to_value(nodes, klass)
+          single_node = nodes if nodes.is_a?(Nokogiri::XML::Node)
+          single_node = nodes[0] if nodes.is_a?(Nokogiri::XML::NodeSet) && 1 == nodes.size
+          if single_node
+            return [klass.new(single_node)] if klass && klass < Atom::Base
+            content = single_node.content
+            return Time.parse(content) if Time == klass
+            return content
+          end
+          if klass < Atom::Base
+            result = []
+            nodes.each {|n| result << klass.new(n)}
+            return result
+          end
+          raise ArgumentError, "Cannot convert node type '#{nodes.class}' to value."
+        end
+        
+        def convert_to_xml(value)
+          case value
+            when Time:
+              value = value.iso8601
+          end
+          value
+        end
+      end
+      
+      elements :title, :id, :authors, :categories
+      elements :contributors, :links, :updated, :summary
+      elements :link_to_self => {"link[@rel='self']/@href" => String}
+      attr_accessor :xml
+      
+      def initialize(xml)
+        @xml = xml
+      end
+        
+      def to_xml!
+        #todo: put in appropriate modules
+        namespaces = @xml.namespaces
+        @xml["xmlns"] = "http://www.w3.org/2005/Atom" unless namespaces["xmlns"]
+        @xml["xmlns:gd"]="http://schemas.google.com/g/2005" unless namespaces["xmlns:gd"]
+#         @xml["xmlns:openSearch"]="http://a9.com/-/spec/opensearch/1.1/"
+#         @xml["xmlns:gml"]="http://www.opengis.net/gml"
+#         @xml["xmlns:georss"]="http://www.georss.org/georss"
+#         @xml["xmlns:batch"]="http://schemas.google.com/gdata/batch"
+        @xml["xmlns:gCal"]="http://schemas.google.com/gCal/2005" unless namespaces["xmlns:gCal"]
+        @xml.to_xml
+      end
+
+    end
+    
+    class Entry < Base
+      elements :content, :published
+    end
+    
+    class Feed < Base
+      elements :generator, :icon
+    end
+  end
+end
+

data/lib/gdata/calendar.rb

@@ -0,0 +1,67 @@
+require 'gdata/atom.rb'
+require 'gdata/data.rb'
+
+module GCal
+  NAMESPACE = "gCal"
+  VERSION = "2.1"
+  
+  class Event < GData::Event
+  end
+  
+  class Feed < GData::Feed
+    creates_entries_of_kind Event
+    
+    attr_reader :magic_cookie, :user_id
+    attr_reader :visibility, :projection
+    #:magic_cookie => ...
+    #:project => one of :full, :basic
+    #:visibility => :private, :public, "magic-cookie"
+    #:projection => :full, :full_noattendees, :composite, :attendees_only, :free_busy, :basic
+    #:user_id => :default, "user@site.com"
+    def initialize(options)
+      @magic_cookie = options.delete(:magic_cookie)
+
+      @visibility = @magic_cookie && !options[:visiblity] \
+      ? :private \
+      : options.delete(:visibility) || :public
+      @projection = options.delete(:projection) || :full
+      @user_id = options.delete(:user_id)
+      raise ArgumentError, "User ID has to be specified for calendar feed" unless user_id
+    end
+    
+    private
+    def feed_url(query = nil)
+      super(query)
+      self.magic_cookie\
+      ? "http://www.google.com/calendar/feeds/#{user_id}/#{visibility}-#{magic_cookie}/#{projection}#{query}"\
+      : "http://www.google.com/calendar/feeds/#{user_id}/#{visibility}/#{projection}#{query}"\
+    end
+    
+    def google_service_name
+      "cl"
+    end
+  end
+  
+  class QueryParams < GData::QueryParams
+    describe_params :ctz=>String, :futureevents => :boolean, :orderby => ["lastmodified", "starttime"]
+    describe_params :recurrance_expansion_start=>:date_or_time, :recurrance_expansion_end=>:date_or_time
+    describe_params :singleevents => :boolean, :showhidden => :boolean, :sortorder => ["ascending", "descending"]
+    describe_params :start_min=>:date_or_time, :start_max=>:date_or_time
+    
+    def initialize
+      self[:singleevents] = true
+      self[:sortorder] = "ascending"
+      self[:orderby] = "starttime"
+    end
+    
+    def validate!
+      self[:recurrance_expansion_start] = self[:start_min] if self[:start_min]
+      self[:recurrance_expansion_end] = self[:start_max] if self[:start_max]
+      super
+    end
+  end
+  
+end
+
+
+

data/lib/gdata/contacts.rb

@@ -0,0 +1,68 @@
+require 'gdata/atom.rb'
+require 'gdata/data.rb'
+
+module GContacts
+  NAMESPACE = "gd"
+  VERSION = "3.0"
+  
+  class Contact < GData::Entry
+    CONTACT_KIND = "http://schemas.google.com/contact/2008#contact"
+    elements :email=>GData::Email, :phone_number=>GData::PhoneNumber, :name=>GData::Name
+    #these elements not implemented yet(todo)
+    #elements :groupMembershipInfo=>GroupMembershipInfo
+    #elements :im=>IM, :postalAddress=>PostalAddress, :organization=>Organization
+    #elements :extended_property=>ExtendedProperty
+    #elements :deleted=>???
+  end
+  
+  class Feed < GData::Feed
+    CLIENT_LOGIN_URL = "https://www.google.com/accounts/ClientLogin"
+    creates_entries_of_kind Contact
+    
+    attr_reader :user_id
+    attr_reader :projection
+    #:projection => one of :full, :thin, :property_key
+    #:user_id => :default, "user@site.com"
+    def initialize(options)
+      @projection = options.delete(:projection) || :full
+      @user_id = options.delete(:user_id)
+      raise ArgumentError, "User ID has to be specified for calendar feed" unless user_id
+    end
+    
+    private
+    def feed_url(query = nil)
+      super(query)
+      "http://www.google.com/m8/feeds/contacts/#{CGI::escape(user_id)}/#{projection}#{query}"
+    end
+    
+    def google_service_name
+      "cp"
+    end
+    
+    def min_entry_xml
+<<ENTRY_END
+<atom:entry xmlns:atom='http://www.w3.org/2005/Atom' xmlns:gd='http://schemas.google.com/g/2005'>
+ <atom:category scheme='http://schemas.google.com/g/2005#kind'
+ term='http://schemas.google.com/contact/2008#contact' />
+  <gd:name>
+     <gd:fullName></gd:fullName>
+     <gd:givenName></gd:givenName>
+     <gd:familyName></gd:familyName>
+  </gd:name>
+</atom:entry>
+ENTRY_END
+    end
+  end
+  
+  class QueryParams < GData::QueryParams
+    describe_params :alt=>String, :max_results => Integer
+    describe_params :start_index => Integer, :updated_min => :date_or_time
+    describe_params :orderby => ["lastmodified"], :showdeleted => :boolean
+    describe_params :sortorder => ["ascending", "descending"]
+    describe_params :group => String
+  end
+  
+end
+
+
+

data/lib/gdata/data.rb

@@ -0,0 +1,228 @@
+require 'gdata/atom.rb'
+require 'gdata/request.rb'
+require 'nokogiri'
+require 'time'
+require 'cgi'
+
+module GData
+  VERSION = "2.1"
+  NAMESPACE = "gd"
+  class << self
+    attr_reader :cache
+    def cache=(c)
+      @cache = c
+      @cache.delete :Auth
+      @cache.delete :gsessionid
+    end
+  end
+
+  class Who < Atom::Base
+    elements :email=>"@email", :rel=>"@rel", :valueString=>"@valueString"
+    elements :attendee_status=>"AttendeeStatus", :attendee_type=>"attendeeType"
+    elements :entry_link=>"entryLink"
+  end
+  
+  class Email < Atom::Base
+    elements :address=>"@address", :label=>"@label", :rel=>"@rel", :primary=>"@primary"
+  end
+  
+  class PhoneNumber < Atom::Base
+    elements :label=>"@label", :rel=>"@rel", :uri=>"@uri", :primary=>"@primary", :text=>"text()"
+  end
+  
+  class Name < Atom::Base
+    elements :given_name => "givenName", :additional_name => "additionalName"
+    elements :family_name => "familyName", :name_prefix => "namePrefix"
+    elements :name_suffix => "nameSuffix", :full_name => "fullName"
+  end
+  
+  class When < Atom::Base
+    elements :start_time => {"@startTime"=>Time}, :end_time => {"@endTime"=>Time}
+  end
+  
+  class Entry < Atom::Entry
+    elements :etag => "@etag"
+    
+    def update!(options = {})
+      ignore_newer_version = options.delete(:ignore_newer_version) || false
+      request = Request.new(link_to_self)
+      put_result = request.put(to_xml!, self.class.atom_header)
+      self.xml = Nokogiri::XML(put_result).xpath("xmlns:entry")[0]
+      self
+    end
+    
+    def delete!(options = {})
+      #todo: implement
+      ignore_newer_version = options.delete(:ignore_newer_version) || false
+    end
+    
+    def reload!(id = nil)
+      url = id || link_to_self
+      request = Request.new(url)
+      header = self.class.atom_header
+      if GData.cache.key?(url)
+        etag = nil
+        cached_entry = Nokogiri::XML(GData.cache[url])
+        etag_attrs = cached_entry.xpath( "xmlns:entry/@gd:etag" )
+        header.merge! "If-None-Match" => etag_attrs[0].to_s if !etag_attrs.empty?
+      end
+      get_result = request.get(header)
+      self.xml = Nokogiri::XML(get_result).xpath("xmlns:entry")[0]
+      self
+    end
+    
+  end
+  
+  class Event < Entry
+    ATTENDEE_KIND = "http://schemas.google.com/g/2005#event.attendee"
+    
+    elements :comments, :status, :recurrence, :transperancy
+    elements :visibility, :where
+    elements :who=>Who, :when=>When
+    elements :when_reminder, :who_attendee_status, :who_attendee_type
+    
+    def start_time; return self.when[0].start_time; end
+    def start_time=(value);self.when[0].start_time = value; end
+    def end_time; return self.when[0].end_time; end
+    def end_time=(value); self.when[0].end_time = value; end
+  end
+  
+  #http://code.google.com/apis/gdata/docs/2.0/reference.html
+  #If the requested feed is in the Atom format, if no query 
+  #parameters are specified, and if the result doesn't contain 
+  #all the entries, the following element is inserted into 
+  #the top-level feed: <link rel="next" type="application/atom+xml" href="..."/>. 
+  #It points to a feed containing the next set of entries.
+  class Feed < Atom::Feed
+    CLIENT_LOGIN_URL = "https://www.google.com/accounts/ClientLogin"
+    elements :etag => "@gd:etag"
+    
+    def fetch_all(query = nil)
+      query = QueryParams.new unless query #so no check for nil needed further in call stack
+      @fetcher = Request.new(feed_url(query))
+      entries = []
+      loop do
+        break unless each_entry do |e| 
+          entry = create_entry(e)
+          entry = yield(entry) if block_given?
+          entries << entry
+        end
+      end
+      entries
+    end
+    
+    def authenticate(password)
+      GData.cache.delete :Auth
+      GData.cache.delete :gsessionid
+      request = GData::Request.new(CLIENT_LOGIN_URL)
+      source = "fkocherga-gdata-1.0" #just library name and version
+      service_name = google_service_name
+      content = "Email=#{CGI::escape(self.user_id)}&Passwd=#{CGI::escape(password)}&source=#{CGI::escape(source)}&service=#{service_name}"
+      body = request.post(content, {'Content-Type' => 'application/x-www-form-urlencoded'})
+      auth_token_re= /Auth=(.+)/
+      auth_token = body[auth_token_re, 1]
+      GData.cache[:Auth] = auth_token
+      self
+    end
+    
+    def new_entry!
+      entry_xml = min_entry_xml
+      entry = create_entry(Nokogiri::XML(entry_xml).xpath("atom:entry")[0])
+      yield(entry) if block_given?
+      request = Request.new(feed_url)
+      entry_xml = request.post(entry.to_xml!, self.class.atom_header)
+      entry = create_entry(Nokogiri::XML(entry_xml).xpath("xmlns:entry")[0])
+      return entry
+    end
+    
+    protected
+    def self.creates_entries_of_kind(klass)
+      define_method :create_entry do |entry_data|
+        klass.new(entry_data)
+      end
+    end
+    creates_entries_of_kind Entry
+    
+    private 
+    def each_entry
+      #note! Even 'If-None-Match' => Etag added to header it does not
+      #lead to 304(Not Modified) reply. Todo: figure out why and is it always behaves this way?
+      feed_chunk = @fetcher.get(self.class.atom_header)
+      @xml = Nokogiri::XML(feed_chunk).search('feed')[0]
+      @xml.search('entry').each do |e|
+        yield e
+      end
+      etag = self.etag
+      next_chunk_url = @xml.search('feed/link[@rel="next"]')
+      return nil if next_chunk_url.empty?
+      @fetcher.url = next_chunk_url[0][:href]
+    end
+    
+    def feed_url(query = nil)
+      query.validate! if query
+    end
+  end #Feed
+
+  
+  class QueryParams < Hash
+    @@params_descriptions = {}
+    
+    #every attribute is nil by default, except
+    #:strict => true(default)
+    #:q => "keyword"
+    #:catetegories => ["Category1", "Category2"]
+    #:entry_id => ...
+    def validate!
+      each do |param, value|
+        raise StandardError, "Query parameter '#{param}' is not supported." unless @@params_descriptions.key? param
+        description = @@params_descriptions[param]
+        case description
+          when Array:
+            raise StandardError, "Param '#{param}' has to be one of '#{description}'"\
+              unless description.find(value)
+          when Class:
+            raise StandardError, "Param '#{param}' has to be instance of class '#{description}'"\
+              unless value.is_a? description
+          when :boolean:
+            raise StandardError, "Param '#{param}' should be true or false."\
+              unless [true, false].find(value)
+          when :date_or_time:
+            raise StandardError, "Param '#{param}' should be Date, Time or DateTime."\
+              unless [Date,Time,DateTime].find(value)
+        end
+      end
+    end
+    
+    def self.describe_params(*params)
+      raise ArgumentError, "Invalid query params #{params}" if params.size > 1 && !params[0].is_a?(Hash)
+      @@params_descriptions.merge!(params[0])
+    end
+    
+    def to_s
+      result = ""
+      each do |param, value|
+        param_name = param.to_s.gsub('_', '-')
+        param_value = value
+        description = @@params_descriptions[param]
+        case description
+          when :date_or_time:
+            case value
+            when Date:
+                param_value = Time.local(value.year, value.month, value.day)
+            when DateTime:
+                param_value = Time.parse(value.to_s)
+            end
+            param_value = param_value.iso8601
+            param_value = CGI::escape(param_value)
+        end
+        result += result.empty? ? "?" : "&"
+        result += "#{param_name}=#{param_value}"
+      end
+      result
+    end
+
+    describe_params :max_results=>:Integer
+
+  end #QueryParams
+  
+end

data/lib/gdata/request.rb

@@ -0,0 +1,119 @@
+require "net/http"
+require 'cgi'
+require "net/https"
+require "gdata/data"
+
+Net::HTTP.version_1_2
+
+module GData
+  class Request
+    attr_reader :query_url
+    def initialize(a_query_url)
+      self.url = a_query_url
+    end
+
+    def url=(query_url)
+      @query_url = query_url
+      @query_uri = URI.parse(query_url)
+      @http_object = Net::HTTP.new(@query_uri.host, @query_uri.port)
+      if @query_uri.scheme == 'https'
+        @http_object.use_ssl = true
+        @http_object.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+    end
+    
+    def use_proxy(address, port, username=nil, password=nil)
+      @http_object = Net::HTTP.new(@query_uri.host, @query_uri.port, address, port, username, password) 
+    end
+    
+    def get(header)
+#       if GData.cache.key? self.query_url
+#         logger.debug "GET: '#{@query_url}' reading cached data"
+#         return GData.cache[self.query_url]
+#       end
+      process_request(:get, nil, header)
+    end
+    
+    def put(content, header)
+      process_request(:put, content, header)
+    end
+    
+    def post(content, header)
+      process_request(:post, content, header)
+    end
+    
+    def process_request(verb, content=nil, header = nil)
+      logger.debug( "#{verb.to_s.upcase}: #{@query_url}")
+#       if content
+#         File.open("#{verb.to_s}.xml", 'w') do |f|
+#           f << content
+#         end
+#       end
+      header = auth_header(header)
+      result = nil
+      location = nil
+      loop do
+        location = result ? result['location'] : @query_url
+        if GData.cache[:gsessionid]
+          query = URI::parse(location).query || ""
+          params = CGI::parse(query) 
+          params['gsessionid'] = "#{GData.cache[:gsessionid]}"
+          location.gsub! /\?.*/, ""
+          request = params.collect {|p,v| "#{p}=#{CGI::escape(v.to_s)}"}
+          request = request.join("&")
+          location = "#{location}?#{request}"
+        end
+        result = @http_object.start do |h| 
+          logger.debug "    sending to '#{location}'..."
+          content\
+            ? h.send(verb, location, content, header) \
+            : h.send(verb, location, header)
+        end
+        case result
+          when Net::HTTPRedirection:
+            logger.debug("    3xx(#{result}): redirect to '#{result['location']}'")
+            if result.is_a? Net::HTTPNotModified
+              logger.debug "    304:not modified, loading cached data"
+              return GData.cache[@query_url]
+            end
+            query = URI::parse(result['location']).query || ""
+            GData.cache[:gsessionid] = CGI::parse(query)['gsessionid'].to_s
+            logger.debug "    updated gsessionid: '#{GData.cache[:gsessionid]}' stored in cache"
+            #             if GData.cache.key? @query_url
+            #               logger.debug "    reading cached data"
+            #               return GData.cache[@query_url] 
+            #             end
+            next
+          end
+        break
+      end
+      if result.is_a?(Net::HTTPSuccess) 
+        logger.debug "    200:success"
+        if :get == verb
+          logger.debug "    storing body in cache for '#{@query_url}'"
+          GData.cache[@query_url] = result.body 
+        end
+#         File.open("#{verb.to_s}.xml", 'w') do |f|
+#           f << result.body
+#         end
+        result.body
+      else
+#         File.open("#{verb.to_s}_error.html", 'w') do |f|
+#           f << result.body
+#         end
+        result.body
+        raise StandardError.new("HTTP #{verb.to_s.upcase} failed.\n #{result.body}")
+      end
+    end
+    
+    def auth_header(header = nil)
+      result = header || {}
+      result.merge! "GData-Version" => GData::VERSION unless result.key? "GData-Version"
+      if GData.cache.key? :Auth
+        result.merge! "Authorization" => "GoogleLogin auth=#{GData.cache[:Auth]}" 
+      end
+      result
+    end
+    
+  end
+end

data/test/calendar_test.rb

@@ -0,0 +1,110 @@
+require File.expand_path(File.dirname(__FILE__)+ '/test_helper')
+
+require 'gdata/calendar'
+
+class GCalendarTest < Test::Unit::TestCase
+  def assert_not_empty(str)
+    assert_not_nil str
+    assert_not_same "", str
+  end
+
+  context "calendar feed" do
+    setup do
+      @calendar = GCal::Feed.new(:user_id=>USER_ID, :visibility=> :private).authenticate(PASSWORD)
+    end
+    
+    should "have default values for visibility and projection" do
+      assert_not_empty @calendar.projection
+      assert_not_empty @calendar.visibility
+    end
+    
+    should "fetch some entries" do
+      events = @calendar.fetch_all
+      assert events.size > 0 
+    end
+
+    context "next week events" do
+      setup do 
+        @query = GCal::QueryParams.new 
+        @tomorrow = Date.today + 1
+        @query[:start_min] = @tomorrow
+        @query[:start_max] = @tomorrow + 7
+        @events = @calendar.fetch_all(@query)
+        assert @events.size > 0
+        @tomorrow_event = @events[0]
+      end
+      
+      should "fetch 7 events for next week" do
+        assert_equal 7, @events.size
+      end
+      
+      should "fetch feed from cache after receiving 304 status" do
+        event = @events[0]
+        event.reload!
+        event.reload!
+      end
+      
+      should "have correct field values" do
+        assert @events.size > 0
+        assert_equal "Oil Painting", @tomorrow_event.title
+        assert_equal Time.local(@tomorrow.year, @tomorrow.month, @tomorrow.day, 10, 00), @tomorrow_event.start_time
+        assert_equal Time.local(@tomorrow.year, @tomorrow.month, @tomorrow.day, 11, 00), @tomorrow_event.end_time
+      end
+      
+      should "save tomorrow's event" do
+        old_time = Time.local(@tomorrow.year, @tomorrow.month, @tomorrow.day, 10, 0)
+        new_time = Time.local(@tomorrow.year, @tomorrow.month, @tomorrow.day, 10, 10)
+
+        @tomorrow_event.start_time = new_time
+        assert_equal new_time, @tomorrow_event.start_time
+        @tomorrow_event.update!
+        updated_event = @calendar.fetch_all(@query)[0]
+        assert_equal new_time, @tomorrow_event.start_time
+        assert_equal new_time, updated_event.start_time
+
+        #NB! bad idea, it supposed to fix test interdependencies
+        #todo: when events deletion/creation is done
+        @tomorrow_event.start_time = old_time
+        @tomorrow_event.update!
+        updated_event = @calendar.fetch_all(@query)[0]
+        assert_equal old_time, @tomorrow_event.start_time
+        assert_equal old_time, updated_event.start_time
+      end
+      
+      should "be possibe to execute consequent update!s" do
+        old_time = Time.local(@tomorrow.year, @tomorrow.month, @tomorrow.day, 10, 0)
+        new_time = Time.local(@tomorrow.year, @tomorrow.month, @tomorrow.day, 10, 10)
+        @tomorrow_event.start_time = new_time + 10
+        @tomorrow_event.update!
+        @tomorrow_event.start_time = old_time
+        @tomorrow_event.update!
+      end
+      
+      should "be possible to add and remove attendee" do
+        who = @tomorrow_event.who
+        assert_equal 1, who.size
+        first_person = who[0]
+        assert_equal USER_ID, first_person.email
+        
+        email = "fkocherga@gmail.com"
+        new_who = @tomorrow_event.add_who
+        new_who.add_email(email)
+        new_who.add_rel(GData::Event::ATTENDEE_KIND)
+        new_who.add_valueString("Fedor Kocherga")
+        @tomorrow_event.update!
+        updated_event = @calendar.fetch_all(@query)[0]
+        assert_equal 2, updated_event.who.size
+        emails = updated_event.who.collect { |w| w.email}
+        assert_same_elements [USER_ID, email], emails
+        
+        @tomorrow_event.remove_who(new_who)
+        @tomorrow_event.update!
+        updated_event = @calendar.fetch_all(@query)[0]
+        assert_equal 1, who.size
+        first_person = who[0]
+        assert_equal USER_ID, first_person.email
+      end
+    end
+  end
+end
+

data/test/contacts_test.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.dirname(__FILE__)+ '/test_helper')
+
+require 'gdata/contacts'
+
+class GContactsTest < Test::Unit::TestCase
+  
+  context "contacts feed" do
+    setup do
+      @feed =  GContacts::Feed.new(:user_id=>USER_ID).authenticate(PASSWORD)
+    end
+    
+    should "fetch some entries" do
+      events = @feed.fetch_all
+      assert events.size > 0 
+    end
+    
+    should "create new contact" do
+      first_name = "Vasya"
+      second_name = "Petrov"
+      full_name = "#{first_name} #{second_name}"
+      phone = "8127777777"
+      contact = @feed.new_entry! do |c|
+        c.name[0].given_name = first_name
+        c.name[0].family_name = second_name
+        c.name[0].full_name = full_name
+        c.phone_number[0] = phone
+        #c.category = ...
+      end
+      assert !contact.link_to_self.empty?
+      contact.reload!
+      #note! full_name is set earlier but comparing with title below - 
+      #if 'title' gets filled up by google, it means contact has been reloaded
+      assert_equal full_name, contact.title
+      #updated_contact.delete!
+    end
+  end
+  
+end
+

data/test/test_helper.rb

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'logger'
+require 'tagged_logger'
+require 'redis'
+
+path = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$:.unshift(path) unless $:.include?(path)
+
+require 'gdata/data'
+
+logger = Logger.new(STDOUT)
+logger.level = Logger::DEBUG
+logger.formatter = lambda {|severity, datetime, progname, msg| "#{msg}"}
+TaggedLogger.use_in_every_class do |level, tag, what|
+  logger.send(level, "#{tag}: #{what}\n")
+end
+
+unless Object.const_defined?(:Debugger)
+  def debugger
+    puts "debugger()..."
+  end
+end
+
+GData.cache = Redis.new
+
+USER_ID = "artery.school.test@gmail.com"
+PASSWORD = "ligovskij"

data/todo.txt

@@ -0,0 +1,18 @@
+- Better DSL for specifying elements:
+  Atom's #elements class method should accept convention adopted by Google: 
+   elements :element - generates 'element=', 'element'
+   elements :element => 'elementName?' - generate 'element=', 'element', 'element?'
+   elements :elements => 'elementName*' - genrates elements behaving like an Array
+
+- Updating fields inline in xml is probably bad idea - Nokogiri is not that fast
+
+- Nokogiri issue: adding gd:node to atom:node creates atom:gd:node (why namespace is inherited when it is explicitly specified?)
+
+- Implement #feed.get(event_id) or #feed.load(event_id), Entry#delete!
+
+- AuthSub authentication
+
+- Creating/Removing feeds
+
+- More tests
+

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: gdata-api
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Fedor Kocherga
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-18 00:00:00 +03:00
+default_executable: 
+dependencies: []
+
+description: 
+email: fkocherga@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Rakefile
+- VERSION
+- gdata-api.gemspec
+- gdata.gemspec
+- lib/gdata/atom.rb
+- lib/gdata/calendar.rb
+- lib/gdata/contacts.rb
+- lib/gdata/data.rb
+- lib/gdata/request.rb
+- test/calendar_test.rb
+- test/contacts_test.rb
+- test/test_helper.rb
+- todo.txt
+has_rdoc: true
+homepage: http://github.com/fkocherga/gdata-api
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Google Data API expressed in Ruby
+test_files: 
+- test/calendar_test.rb
+- test/contacts_test.rb