More work on refactoring the dbus interface:

  * zeitgeist/dbusutils.py:
    - changed datatype of events from tuple to a dict
    - removed plainify_dict() and dictify_data(), both functions are not
      needed anymore
  * zeitgeist-datahub: we don't need to convert items to a tuple anymore
    as the DBus API now accepts a dict
  * zeitgeist/engine/engine.py:
    - changed ZeitgeistEngine._format_result() to return a dict
    - make sure API methods to return dicts instead of tuples
  * zeitgeist/engine/remote.py: 
    - removed code to convert items to dict, as they are dicts now anyway
    - RemoteInterface.EventsChanged signal now returns a tuple instead   
      of a dict (LP: #398379). Note: the current solution will not work
      in case of a 'deleted' action because of a restriction in python's
      dbus implementation where a variant type cannot be a dictionary
  * test/engine-engine-test.py: adjusted the testcases for the engine to
    the new datatype of events

5 files changed, 66 insertions, 67 deletions

diff --git a/test/engine-engine-test.py b/test/engine-engine-test.py
index ec9750b3..b2982e8f 100755
--- a/test/engine-engine-test.py
+++ b/test/engine-engine-test.py
@@ -67,7 +67,6 @@ class ZeitgeistEngineTest (unittest.TestCase):
 		self.assertTrue(result is not None)
 		
 		# Clean result, from extra data, and add missing data
-		result = dictify_data(result)
 		result["use"] = Content.CREATE_EVENT.uri
 		result["app"] = "/usr/share/applications/gnome-about.desktop"
 	
@@ -97,8 +96,8 @@ class ZeitgeistEngineTest (unittest.TestCase):
 					"tags": ""
 		}
 		self.engine.insert_event(orig)
-		bookmarks = map(dictify_data, self.engine.find_events(0, 0, 0, True,
-			"event", [{"bookmarked": True}]))
+		bookmarks = self.engine.find_events(0, 0, 0, True,
+						"event", [{"bookmarked": True}])
 		self.assertEquals(1, len(bookmarks))
 		self.assertEquals("test://mytest", bookmarks[0]["uri"])
 		self.assertEquals([], list(self.engine.get_tags()))
@@ -327,7 +326,7 @@ class ZeitgeistEngineTest (unittest.TestCase):
 	def testFindEventsMostUsed(self):
 		self._init_with_various_events()
 		result = self.engine.find_events(0, 0, 0, True, "mostused", [])
-		self.assertEquals(result[0][2], u"Cool Picture 1")
+		self.assertEquals(result[0]["text"], u"Cool Picture 1")
 	
 	def testFindEventsMimetype(self):
 		self._init_with_various_events()
@@ -339,7 +338,7 @@ class ZeitgeistEngineTest (unittest.TestCase):
 		self._init_with_various_events()
 		result = self.engine.find_events(0, 0, 0, True, "event",
 			[{"mimetypes": [u"image/j%", u"image/_n_"]}])
-		self.assertEquals(set([x[5] for x in result]),
+		self.assertEquals(set([x["mimetype"] for x in result]),
 			set([u"image/jpg", u"image/png"]))
 	
 	def testFindEventsMimetypeAndBookmarks(self):
@@ -356,9 +355,9 @@ class ZeitgeistEngineTest (unittest.TestCase):
 	
 	def testFindEventsWithTags(self):
 		self._init_with_various_events()
-		result1 = [x[1] for x in self.engine.find_events(0, 0, 0, True, "event",
+		result1 = [x["uri"] for x in self.engine.find_events(0, 0, 0, True, "event",
 			[{"tags": [u"files"]}])]
-		result2 = [x[1] for x in self.engine.find_events(0, 0, 0, True, "event",
+		result2 = [x["uri"] for x in self.engine.find_events(0, 0, 0, True, "event",
 			[{"tags": [u"files", u"examples"]}])]
 		self.assertEquals(result1, result2)
 		self.assertEquals(result1, [u"file:///tmp/files/example.png"])
@@ -374,8 +373,8 @@ class ZeitgeistEngineTest (unittest.TestCase):
 		result4 = self.engine.find_events(0, 0, 0, True, "event",
 			[{"content": [Content.MUSIC.uri]}])
 		self.assertEquals(result1, result2)
-		self.assertEquals([x[4] for x in result1], [Content.IMAGE.uri] * 4)
-		self.assertEquals(result3[0][2],  u"picture.png")
+		self.assertEquals([x["content"] for x in result1], [Content.IMAGE.uri] * 4)
+		self.assertEquals(result3[0]["text"],  u"picture.png")
 		self.assertEquals(len(result3), 1)
 		self.assertEquals(len(result4), 0)
 	
@@ -388,7 +387,7 @@ class ZeitgeistEngineTest (unittest.TestCase):
 		result3 = self.engine.find_events(0, 0, 0, True, "event",
 			[{"source": [Source.USER_NOTIFICATION.uri]}])
 		self.assertEquals(len(result1), 3)
-		self.assertEquals(set(x[3] for x in result2),
+		self.assertEquals(set(x["source"] for x in result2),
 			set([Source.WEB_HISTORY.uri]))
 		self.assertEquals(len(result2), 2)
 		self.assertEquals(len(result3), 0)
diff --git a/zeitgeist-datahub b/zeitgeist-datahub
index 9d75cdc0..662c7633 100755
--- a/zeitgeist-datahub
+++ b/zeitgeist-datahub
@@ -36,7 +36,7 @@ installation_dir = os.path.dirname(os.path.realpath(config.__file__))
 datasource_dir = os.path.join(installation_dir, "loggers/datasources")
 sys.path.append(datasource_dir)
 
-from zeitgeist.dbusutils import DBusInterface, plainify_dict
+from zeitgeist.dbusutils import DBusInterface
 
 class DataHub(gobject.GObject):
 	
@@ -107,12 +107,12 @@ class DataHub(gobject.GObject):
 		logging.debug(_("Updating database with new %s items") % \
 			self._sources_queue[0].get_name())
 		
-		items = set()
+		items = list()
 		for num, item in enumerate(self._sources_queue[0].get_items()):
-			items.add(plainify_dict(item))
+			items.append(item)
 			if num % 200 == 0:
 				self._insert_events(self._sources_queue[0].get_name(), items)
-				items = set()
+				items = list()
 		if items:
 			self._insert_events(self._sources_queue[0].get_name(), items)
  		
diff --git a/zeitgeist/dbusutils.py b/zeitgeist/dbusutils.py
index 564f212a..3c43992a 100644
--- a/zeitgeist/dbusutils.py
+++ b/zeitgeist/dbusutils.py
@@ -94,33 +94,31 @@ class DBusInterface(dbus.Interface):
 				self.BUS_NAME
 		)
 
-# (isssssssbssss)
-ITEM_STRUCTURE = (
-	("timestamp", int),
-	("uri", unicode),
-	("text", unicode),
-	("source", unicode),
-	("content", unicode),
-	("mimetype", unicode),
-	("tags", unicode),
-	("comment", unicode),
-	("bookmark", bool),
-	("use", unicode),
-	("icon", unicode),
-	("app", unicode),
-	("origin", unicode),
-)
+ITEM_STRUCTURE = {
+	"timestamp": int,
+	"uri": unicode,
+	"text": unicode,
+	"source": unicode,
+	"content": unicode,
+	"mimetype": unicode,
+	"tags": unicode,
+	"comment": unicode,
+	"bookmark": bool,
+	"use": unicode,
+	"icon": unicode,
+	"app": unicode,
+	"origin": unicode,
+}
 
-ITEM_STRUCTURE_KEYS = set(i[0] for i in ITEM_STRUCTURE)
+ITEM_STRUCTURE_KEYS = set(ITEM_STRUCTURE.keys())
 
-DEFAULTS = {int: 0, unicode: "", bool: False}
+DEFAULTS = {int: 0, unicode: "", bool: False} #can be reomved
 TYPES = {int: "i", unicode: "s", bool: "b"}
 TYPES_DICT = dict(ITEM_STRUCTURE) 
 
-sig_plain_data = "(%s)" %"".join(TYPES[i[1]] for i in ITEM_STRUCTURE)
+#~ sig_plain_data = "(%s)" %"".join(TYPES[i[1]] for i in ITEM_STRUCTURE)
+sig_plain_data = "a{sv}"
 
-def plainify_dict(item_list):
-	return tuple(item_list.get(name, DEFAULTS[type]) for name, type in ITEM_STRUCTURE)
-
-def dictify_data(item_list):
-	return dict((key[0], item_list[i]) for i, key in enumerate(ITEM_STRUCTURE))
+def check_dict(event_dict):
+	return dict((key, event_dict.get(key, type())) for key, type in TYPES_DICT.iteritems())
+		
diff --git a/zeitgeist/engine/engine.py b/zeitgeist/engine/engine.py
index b8c54674..e0e78c40 100644
--- a/zeitgeist/engine/engine.py
+++ b/zeitgeist/engine/engine.py
@@ -33,7 +33,7 @@ import sqlite3
 
 from zeitgeist import config
 from zeitgeist.engine.base import *
-from zeitgeist.dbusutils import ITEM_STRUCTURE_KEYS, TYPES_DICT, plainify_dict
+from zeitgeist.dbusutils import ITEM_STRUCTURE_KEYS, TYPES_DICT
 
 logging.basicConfig(level=logging.DEBUG)
 log = logging.getLogger("zeitgeist.engine")
@@ -75,21 +75,21 @@ class ZeitgeistEngine(gobject.GObject):
 		information and converts it into a tuple suitable for transmission
 		over D-Bus. """
 		
-		return (
-			value[1], # timestamp
-			value[0], # uri
-			value[7] or os.path.basename(value[0]), # name
-			value[5], # source
-			value[3], # content
-			value[8], # mimetype
-			value[12] or "", # tags
-			"", # comment
-			bool(value[11]), # bookmark
-			value[4], # usage is determined by the event Content type # event.item.content.value
-			value[9], # icon
-			value[10], # app
-			value[6] # origin
-			)
+		return {
+			"timestamp": value[1],
+			"uri": value[0],
+			"text": value[7] or os.path.basename(value[0]), # FIXME: why not u"" as alternative value?
+			"source": value[5], 
+			"content": value[3],
+			"mimetype": value[8],
+			"tags": value[12] or u"",
+			"comment": u"",
+			"bookmark": bool(value[11]),
+			"use": value[4], # usage is determined by the event Content type # event.item.content.value
+			"icon": value[9],
+			"app": value[10],
+			"origin": value[6],
+		}
 	
 	def _get_ids(self, uri, content, source):	
 		uri_id = URI.lookup_or_create(uri).id if uri else None
@@ -238,7 +238,7 @@ class ZeitgeistEngine(gobject.GObject):
 			# This is always 0 or 1, no need to consider 2 as we don't
 			# use the `force' option.
 			if self.insert_event(item, commit=False):
-				inserted_items.append(plainify_dict(item))
+				inserted_items.append(item)
 		self.store.commit()
 		time2 = time.time()
 		log.debug("Inserted %s items in %.5f s." % (len(inserted_items),
@@ -447,7 +447,7 @@ class ZeitgeistEngine(gobject.GObject):
 	
 	def update_items(self, items):
 		map(self._update_item, items)
-		return [plainify_dict(item) for item in items]
+		return items
 	
 	def _delete_item(self, uri):
 		
diff --git a/zeitgeist/engine/remote.py b/zeitgeist/engine/remote.py
index 258e7a73..96b44df8 100644
--- a/zeitgeist/engine/remote.py
+++ b/zeitgeist/engine/remote.py
@@ -22,7 +22,7 @@ import dbus.service
 import logging
 
 from zeitgeist.engine.engine import get_default_engine
-from zeitgeist.dbusutils import DBusInterface, dictify_data, sig_plain_data
+from zeitgeist.dbusutils import DBusInterface, sig_plain_data, check_dict
 from zeitgeist.singleton import SingletonApplication
 
 _engine = get_default_engine()
@@ -86,7 +86,7 @@ class RemoteInterface(SingletonApplication):
 		#   content: <str>
 		#   bookmarked: <bool> (True means bookmarked items, and vice versa
 		return _engine.find_events(min_timestamp, max_timestamp, limit,
-			sorting_asc, mode, filters, False)
+					sorting_asc, mode, filters, False)
 	
 	@dbus.service.method(DBUS_INTERFACE,
 						in_signature="iisaa{sv}", out_signature="i")
@@ -174,9 +174,9 @@ class RemoteInterface(SingletonApplication):
 		:returns: a positive value on success, ``0`` otherwise
 		:rtype: Integer
 		"""
-		result = _engine.insert_events([dictify_data(x) for x in event_list])
+		result = _engine.insert_events(map(check_dict, event_list))
 		if result:
-			self.EventsChanged({"added": result})
+			self.EventsChanged(("added", result))
 			return len(result)
 		else:
 			return 0
@@ -189,8 +189,8 @@ class RemoteInterface(SingletonApplication):
 		:param item_list: list of items to be inserted in the database
 		:type item_list: list of tuples presenting an :ref:`item-label`
 		"""
-		result = _engine.update_items([dictify_data(x) for x in item_list])
-		self.EventsChanged({"modified": result})
+		result = _engine.update_items(item_list)
+		self.EventsChanged(("modified", result))
 	
 	@dbus.service.method(DBUS_INTERFACE,
 						in_signature="as", out_signature="")
@@ -201,22 +201,24 @@ class RemoteInterface(SingletonApplication):
 		:type uris: list of strings
 		"""
 		result = _engine.delete_items(uris)
-		self.EventsChanged({"deleted": result})
+		self.EventsChanged(("deleted", result)) #FIXME, this will not work
 	
 	# Signals and signal emitters
 	
 	@dbus.service.signal(DBUS_INTERFACE,
-						signature="a{sv}")
+						signature="(sa%s)" %sig_plain_data)
 	def EventsChanged(self, value):
 		"""This Signal is emmitted whenever one or more items have been changed
 		
-		It contains a list of dictionaries containing one or more of `added`,
-		`modified` and `deleted`, where the first two contain the affected
-		items and the later only their URI.
+		It contains a tuple, where the first item is one of `added`,
+		`modified` and `deleted`. If the first item is `added` or `modified`
+		the second item is a list of :ref:`item-label`, otherwise it is
+		a list of uris.
 		
 		:returns: added and modified items and URIs of deleted items
 		:rtype: list of dictionaries
 		"""
+		# FIXME: this is broken in case of "deleted" actions
 		return value
 	
 	@dbus.service.signal(DBUS_INTERFACE)