Change Google Calendar Events.. in Scala

It' been over 3 years since I finished my internship at Google, and lots of things happened in Scala-land since. A couple of days ago I went back to my code I wrote back then, and ported it to Scala 2.9.0.RC1. The project is a Scala client library for Google Data APIs.

The GData Scala Client Library

Google Data (or GData) is an Atom-based publishing protocol that allows CRUD operations over Google services, such as Calendar, YouTube, GMail, etc. It is a very powerful mechanism that allows programatic access to all your Google-based thingies, but being XML-based it is very cumbersome to use directly. Google maintains a bunch of client libraries in different languages that hide all the ugly XML from programmers' eyes.

While at Google, I wrote a Scala client library, and I am still very pleased with the result. I strayed away from their Java client architecture, and for XML handling I wrote a pickler library. However, unlike the original paper that deals with sequential data, I had to make it work with XML trees, which proved a lot more interesting. Briefly, the library allows one to define bi-directional mapping between user types and XML using syntax that's reminiscent of Relax-NG schemas:

def pickler: Pickler[Rating] =
    elem("rating",
          opt(attr("average", doubleVal))
        ~ attr("min", intVal)
        ~ attr("max", intVal)
        ~ opt(attr("numRaters", intVal))
        ~ default(attr("rel", text), "overall")
        ~ opt(attr("value", intVal)))(gdNs)

This code defines an element called 'rating' with an optional attribute average, of type Double, two required attributes of type int (min and max), an attribute with a default string value, and so on. This pickler defines two methods, one from XML to instances of Reminder, and another from Reminder to XML. The library provides type-safe, user-extensible picklers, meaning that the result of unpickling an XML element like

<rating average="2.5" min="1" max="5"/>

will be an instance of the Rating class, and serializing an instance of Rating would generate conforming XML. One of the difficulties I faced was to allow permutation of child elements when parsing (the Atom protocol is very liberal in this regard, and Google servers use this liberty). I won't go further into the details of the implementation, as it is nicely described in the Developer's guide.

The other part of the library deals with HTTP requests and binds together the XML serialization code with the network protocol.

Updating birthday entries

A couple of months ago I decided to organize my birthday calendar, and realized that most of the entries had a reminder, but some did not. This resulted in the suboptimal situation that I forgot some birthdays, but not all. I decided to fix this.. programmatically.

The code to do it in Scala is surprisingly simple:

package anivs

import com.google.gdata.calendar._
import com.google.gdata.data.kinds.Reminder
import Schemas._

object ChangeAnivs extends Application {
  final val calName = "Birthdays"
  val s = new CalendarService("test")
  s.setUserCredentials("username@gmail.com", "secret")

  val cal = s.getOwnedUserCalendars.find(_.title.content.startsWith(calName)) match {
	case Some(bcal) => bcal
	case _ =>
	  println("couldn't find calendar")
	  exit(1)
  }
  var link = cal.link(EVENT_FEED)

  while (link.isDefined) {
    val events = s.getEvents(link.get.href)
    println("* got back " + events.length + " events")
    addReminders(events)
    link = events.link("next")
  }

  implicit def toOpt[T](s: T): Option[T] = Option(s)

  def addReminders(events: s.eventsFeed.Feed) {
    for (event <- events if event.reminders.isEmpty) {
      // alert 10 min before event
      val rem = Reminder(method = "alert", minutes = 10)
      event.reminders = List(rem)
      val e1 = s.updateEvent(event)
      println("Updated event " + e1.title.content)
    }
  }
}

That's it! It adds a popup reminder to each event that has no reminders. Notice that the reminder uses named parameters, and the class has default values for most of its parameters (Atom has plenty of optional elements and attributes). I also added an implicit conversion from Any to Option, so that I don't need to wrap Some around the parameters I passed to Reminder.

Next steps

I plan a number of improvements to the code. GData-scala-client was developed before sbt came to the scene, so I'd like to move the build from ant to sbt and publish it to the scala-tools.org maven repository. I already went through most GData-defined types and added default arguments and plan to more consistently use named parameters where possible. This should make the code much easier to understand. And lastly, I might add support for other services (currently, it supports Calendar, YouTube and Contacts) -- I'm a bit reluctant to say this too loud, though..