revolution 0.1

data/extconf.rb

@@ -0,0 +1,7 @@
+require 'mkmf'
+
+$CPPFLAGS += " -Wall " + `pkg-config --cflags libebook-1.0 libecal-1.0 glib-2.0 evolution-data-server-1.0`
+$LOCAL_LIBS += `pkg-config --libs libebook-1.0 libecal-1.0`
+
+create_makefile("revolution")
+

data/revolution.c

@@ -0,0 +1,399 @@
+#include <stdio.h>
+
+#include "ruby.h"
+
+#include "glib.h"
+#include <glib-object.h>
+
+#include <libebook/e-book.h>
+#include <libecal/e-cal.h>
+
+#include <libical/pvl.h>
+#include <libical/ical.h>
+
+#include <libical/icalcomponent.h>
+#include <libical/icalproperty.h>
+#include <libical/icalvalue.h>
+#include <libical/icaltime.h>
+#include <libical/icalenums.h>
+
+VALUE crRevolution;
+VALUE module;
+
+/* 
+ *	call-seq:
+ *		new() -> Revolution
+ *		
+ * Creates a new Revolution object
+ */
+static VALUE revolution_init(VALUE self) {
+	return Qnil;
+}
+
+static gint cal_opened_status = -1;
+
+static void revolution_calendar_opened_callback(ECal* calendar, gint arg, gpointer user_data) {
+	cal_opened_status = arg;
+}
+
+void copy_summary(const VALUE ruby_obj, ECalComponent* ev_obj) {
+	ECalComponentText summary;
+	e_cal_component_get_summary(ev_obj, &summary);
+	rb_iv_set(ruby_obj, "@summary", rb_str_new2(summary.value ? summary.value : ""));
+}
+
+void copy_start(const VALUE ruby_obj, ECalComponent* ev_obj) {
+	ECalComponentDateTime start;
+	e_cal_component_get_dtstart(ev_obj, &start);
+	if (start.value) {
+		rb_iv_set(ruby_obj, "@start", rb_funcall( rb_cTime, rb_intern( "at" ), 1, INT2NUM(icaltime_as_timet(*start.value))));
+		e_cal_component_free_datetime(&start);
+	}
+}
+
+void copy_last_modification(const VALUE ruby_obj, ECalComponent* ev_obj) {
+	struct icaltimetype* last_mod;
+	e_cal_component_get_last_modified(ev_obj, &last_mod);
+	if (last_mod) {
+		rb_iv_set(ruby_obj, "@last_modification", rb_funcall( rb_cTime, rb_intern( "at" ), 1, INT2NUM(icaltime_as_timet(*last_mod))));
+	}
+}
+
+void copy_uid(const VALUE ruby_obj, ECalComponent* ev_obj) {
+	const char* uid;
+	e_cal_component_get_uid(ev_obj, &uid);
+	if (uid) {
+		rb_iv_set(ruby_obj, "@uid", rb_str_new2(uid));
+	}
+}
+
+
+///////////////////////////////////////////////////////
+// Tasks
+VALUE crEvTask;
+
+/* 
+ *	call-seq:
+ *		new() -> EvTask
+ *		
+ * Creates a new EvTask object
+ */
+static VALUE evTask_init(VALUE self) {
+  rb_define_attr(crEvTask, "uid", 1, 0);
+  rb_define_attr(crEvTask, "summary", 1, 0);
+  rb_define_attr(crEvTask, "description", 1, 0);
+  rb_define_attr(crEvTask, "start", 1, 0);
+  rb_define_attr(crEvTask, "due", 1, 0);
+  rb_define_attr(crEvTask, "last_modification", 1, 0);
+	return Qtrue;
+}
+
+void copy_into_task(const VALUE ruby_task, ECalComponent* ev_task) {
+		copy_uid(ruby_task, ev_task);
+		copy_summary(ruby_task, ev_task);
+		copy_last_modification(ruby_task, ev_task);
+		copy_start(ruby_task, ev_task);
+
+		// Note that task have only one description, so this singly-linked list
+		// has no more than one element.  This is as opposed to a journal object, which
+		// has multiple description entries.
+		GSList* descriptions = NULL;
+		e_cal_component_get_description_list(ev_task, &descriptions);
+		if (descriptions) {
+			ECalComponentText* desc = (ECalComponentText*)descriptions->data;
+			rb_iv_set(ruby_task, "@description", rb_str_new2(desc->value ? desc->value: ""));
+		}
+		e_cal_component_free_text_list(descriptions);
+
+		ECalComponentDateTime due_date;
+		e_cal_component_get_due(ev_task, &due_date);
+		if (due_date.value) {
+			rb_iv_set(ruby_task, "@due", rb_funcall( rb_cTime, rb_intern( "at" ), 1, INT2NUM(icaltime_as_timet(*due_date.value))));
+			e_cal_component_free_datetime(&due_date);
+		}
+}
+
+/* 
+ *	call-seq:
+ *		get_all_tasks() -> Array
+ *		
+ * Fetches all tasks 
+ */
+static VALUE revolution_get_all_tasks(VALUE self) {
+	VALUE result = rb_ary_new();
+
+ 	ECal* cal = e_cal_new_system_tasks();
+	g_signal_connect(G_OBJECT(cal), "cal-opened", G_CALLBACK(revolution_calendar_opened_callback), NULL);
+	GError* error = 0;
+	e_cal_open(cal, FALSE, &error);
+	if (error) {
+		g_warning("Unable to open calendar: %s", error->message);
+		g_clear_error(&error);
+		return result;
+	}
+
+	while (cal_opened_status == -1) {
+		g_usleep(G_USEC_PER_SEC*0.01);
+	}
+	if (cal_opened_status != 0) {
+		g_warning("Unable to open calendar; error code %d", cal_opened_status);
+		return result;
+	}
+	
+	GList* objects, *l;
+	// #t == true, i.e. return everything
+	e_cal_get_object_list_as_comp(cal, "#t", &objects, &error);
+	if (error) {
+		g_warning("Unable to query calendar: %s", error->message);
+		g_clear_error(&error);
+		return result;
+	}
+
+	for (l = objects; l;l = l->next) {
+    ECalComponent *ev_task = E_CAL_COMPONENT (l->data);
+		VALUE ruby_task = rb_class_new_instance(0, 0, crEvTask);
+		copy_into_task(ruby_task, ev_task);
+		rb_ary_push(result, ruby_task);	
+    g_object_unref (ev_task);
+  }
+
+	return result;
+}
+
+///////////////////////////////////////////////////////
+// Calendar
+VALUE crEvAppointment;
+
+/* 
+ *	call-seq:
+ *		new() -> EvAppointment
+ *		
+ * Creates a new EvAppointment object
+ */
+static VALUE evAppointment_init(VALUE self) {
+  rb_define_attr(crEvAppointment, "uid", 1, 0);
+  rb_define_attr(crEvAppointment, "summary", 1, 0);
+  rb_define_attr(crEvAppointment, "location", 1, 0);
+  rb_define_attr(crEvAppointment, "organizer", 1, 0);
+  rb_define_attr(crEvAppointment, "start", 1, 0);
+  rb_define_attr(crEvAppointment, "end", 1, 0);
+  rb_define_attr(crEvAppointment, "last_modification", 1, 0);
+  rb_define_attr(crEvAppointment, "alarm_set", 1, 0);
+  rb_define_attr(crEvAppointment, "busy_status", 1, 0);
+  rb_define_attr(crEvAppointment, "recurring", 1, 0);
+  // INLINE RUBY CODE define an "all_day" method
+  return Qtrue;
+}
+
+void copy_into_appt(const VALUE ruby_appt, ECalComponent* ev_appt) {
+		copy_uid(ruby_appt, ev_appt);
+		copy_summary(ruby_appt, ev_appt);
+		copy_start(ruby_appt, ev_appt);
+		copy_last_modification(ruby_appt, ev_appt);
+
+		const char* location;
+		e_cal_component_get_location(ev_appt, &location);
+		if (location) {
+			rb_iv_set(ruby_appt, "@location", rb_str_new2(location));
+		}
+	
+		// there's probably a good way to combine this with due_date
+		ECalComponentDateTime end;
+		e_cal_component_get_dtend(ev_appt, &end);
+		if (end.value) {
+			rb_iv_set(ruby_appt, "@end", rb_funcall( rb_cTime, rb_intern( "at" ), 1, INT2NUM(icaltime_as_timet(*end.value))));
+			e_cal_component_free_datetime(&end);
+		}
+
+		ECalComponentOrganizer organizer;
+		e_cal_component_get_organizer(ev_appt, &organizer);
+		if (organizer.value) {
+			if (!g_strncasecmp(organizer.value, "mailto:", 7)) {
+				organizer.value += 7;
+			}
+			rb_iv_set(ruby_appt, "@organizer", rb_str_new2(organizer.value?organizer.value: ""));
+		}
+
+		ECalComponentTransparency transp;
+		e_cal_component_get_transparency(ev_appt, &transp);
+		// This should probably be an int or enum or some such rather than just a true/false
+		rb_iv_set(ruby_appt, "@busy_status", transp == E_CAL_COMPONENT_TRANSP_OPAQUE ? Qtrue : Qfalse);
+
+		rb_iv_set(ruby_appt, "@alarm_set", e_cal_component_has_alarms(ev_appt) ? Qtrue : Qfalse);
+		rb_iv_set(ruby_appt, "@recurring", e_cal_component_has_recurrences(ev_appt) ? Qtrue : Qfalse);
+}
+
+/* 
+ *	call-seq:
+ *		get_all_appointments(start, end) -> Array
+ *		
+ * Fetches all appointments between the given Time values.
+ */
+static VALUE revolution_get_all_appointments(VALUE self, VALUE start, VALUE end) {
+	VALUE result = rb_ary_new();
+
+	// This works, but what about getting an ESourceList and all that?
+ 	ECal* cal = e_cal_new_system_calendar();
+	g_signal_connect(G_OBJECT(cal), "cal-opened", G_CALLBACK(revolution_calendar_opened_callback), NULL);
+	GError* error = 0;
+	e_cal_open(cal, FALSE, &error);
+	if (error) {
+		g_warning("Unable to open calendar: %s", error->message);
+		g_clear_error(&error);
+		return result;
+	}
+
+	while (cal_opened_status == -1) {
+		g_usleep(G_USEC_PER_SEC*0.01);
+	}
+	if (cal_opened_status != 0) {
+		g_warning("Unable to open calendar; error code %d", cal_opened_status);
+		return result;
+	}
+	
+	GList* results, *l;
+	e_cal_get_object_list_as_comp(cal, "#t", &results, &error);
+	if (error) {
+		g_warning("Unable to query calendar: %s", error->message);
+		g_clear_error(&error);
+		return result;
+	}
+
+	for (l = results; l;l = l->next) {
+    ECalComponent *ev_appt = E_CAL_COMPONENT(l->data);
+		VALUE ruby_appt = rb_class_new_instance(0, 0, crEvAppointment);
+		copy_into_appt(ruby_appt, ev_appt);
+		rb_ary_push(result, ruby_appt);	
+    g_object_unref (ev_appt);
+  }
+
+  g_list_free(results);
+
+	return result;
+}
+
+
+///////////////////////////////////////////////////////
+// Address Book
+VALUE crEvContact;
+
+/* 
+ *	call-seq:
+ *		new() -> EvContact
+ *		
+ * Creates a new EvContact object
+ */
+static VALUE evContact_init(VALUE self) {
+  rb_define_attr(crEvContact, "uid", 1, 0);
+  rb_define_attr(crEvContact, "first_name", 1, 0);
+  rb_define_attr(crEvContact, "last_name", 1, 0);
+  rb_define_attr(crEvContact, "home_email", 1, 0);
+  rb_define_attr(crEvContact, "work_email", 1, 0);
+  return Qtrue;
+}
+
+char* fetch_field_or_empty_str(EContact* ev_contact, const EContactField field) {
+	char* value = e_contact_get(ev_contact, field);
+	return (value) ? value : "";
+}
+
+void copy_into_contact(const VALUE ruby_contact, EContact* ev_contact) {
+		// last mod time will work in v2.16+ :  e_contact_get (ev_contact, E_CONTACT_REV));
+		rb_iv_set(ruby_contact, "@uid", rb_str_new2(fetch_field_or_empty_str(ev_contact, E_CONTACT_UID)));
+		rb_iv_set(ruby_contact, "@first_name", rb_str_new2(fetch_field_or_empty_str(ev_contact, E_CONTACT_GIVEN_NAME)));
+		rb_iv_set(ruby_contact, "@last_name", rb_str_new2(fetch_field_or_empty_str(ev_contact, E_CONTACT_FAMILY_NAME)));
+
+		gpointer email1 = e_contact_get(ev_contact, E_CONTACT_EMAIL);
+		if (email1) {
+			GList* attrs, *attr;
+			attrs = e_contact_get_attributes(ev_contact, E_CONTACT_EMAIL);
+			for (attr = attrs; attr ; attr = attr->next) {
+				EVCardAttribute* a = attr->data; // g_message("attr name = %s\n", e_vcard_attribute_get_name(a));
+				char* value = e_vcard_attribute_get_value(a);
+				GList* params, *l;
+				params = e_vcard_attribute_get_params(a);
+				for (l = params; l; l = l->next) {
+					EVCardAttributeParam* p = l->data;
+					if (!g_ascii_strcasecmp((char*)e_vcard_attribute_param_get_name(p), "TYPE")) {
+						char* type = e_vcard_attribute_param_get_values(p)->data;
+						if (!g_ascii_strcasecmp(type, "WORK")) {
+							rb_iv_set(ruby_contact, "@work_email", rb_str_new2(value));
+						} else if (!g_ascii_strcasecmp(type, "HOME")) {
+							rb_iv_set(ruby_contact, "@home_email", rb_str_new2(value));
+						}
+					}
+				}
+			}	
+		}
+}
+
+/* 
+ *	call-seq:
+ *		get_all_contacts() -> Array
+ *		
+ * Fetches all contacts 
+ */
+static VALUE revolution_get_all_contacts(VALUE self) {
+	VALUE result = rb_ary_new();
+  GError* error = 0;
+  EBook* book = e_book_new_default_addressbook(&error);
+	if (error != NULL) {
+		g_warning("Unable to locate the default Evolution address book: %s", error->message);
+		g_clear_error(&error);
+		return result;
+	}
+
+  e_book_open(book, TRUE, &error);
+	if (error) {
+		g_warning("Unable to open the Evolution address book: %s", error->message);
+		g_clear_error(&error);
+		return result;
+	}
+
+  EBookQuery* query = e_book_query_any_field_contains("");
+
+  GList* results, *l = NULL;
+  e_book_get_contacts(book, query, &results, &error);
+	if (error) {
+		g_warning("Unable to query the Evolution address book: %s", error->message);
+		g_clear_error(&error);
+		return result;
+	}
+  for (l = results; l; l = l->next) {
+  	EContact* ev_contact = E_CONTACT(l->data);
+		VALUE ruby_contact = rb_class_new_instance(0, 0, crEvContact);
+		copy_into_contact(ruby_contact, ev_contact);
+		rb_ary_push(result, ruby_contact);	
+  	g_object_unref(ev_contact);
+  }
+  e_book_query_unref(query);
+  g_list_free(results);
+
+	return result;
+}
+
+/*
+ * An interface to the Evolution[http://www.gnome.org/projects/evolution/] 
+ * calendar, contact, and task information.
+ */
+void Init_revolution() {
+	module = rb_define_module("Revolution");
+
+  crEvContact = rb_define_class_under(module, "EvContact", rb_cObject);
+  rb_define_method(crEvContact, "initialize", evContact_init, 0);
+
+  crEvAppointment = rb_define_class_under(module, "EvAppointment", rb_cObject);
+  rb_define_method(crEvAppointment, "initialize", evAppointment_init, 0);
+
+  crEvTask = rb_define_class_under(module, "EvTask", rb_cObject);
+  rb_define_method(crEvTask, "initialize", evTask_init, 0);
+
+	crRevolution = rb_define_class_under(module, "Revolution", rb_cObject);
+	rb_define_method(crRevolution, "initialize", revolution_init, 0);
+	rb_define_method(crRevolution, "get_all_contacts", revolution_get_all_contacts, 0);
+	rb_define_method(crRevolution, "get_all_appointments", revolution_get_all_appointments, 2);
+	rb_define_method(crRevolution, "get_all_tasks", revolution_get_all_tasks, 0);
+
+	g_type_init();
+}
+

metadata

@@ -0,0 +1,39 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.8
+specification_version: 1
+name: revolution
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+date: 2005-03-21
+summary: Revolution is a binding for the Evolution email client
+require_paths: 
+  - ''
+email: tom@infoether.com
+homepage: http://revolution.rubyforge.org/
+rubyforge_project: revolution
+description: 
+autorequire: revolution
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.0
+  version: 
+platform: ruby
+authors: 
+  - Tom Copeland
+files: 
+  - revolution.c
+  - extconf.rb
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: 
+  - extconf.rb
+requirements: []
+dependencies: []