Merge lp:~thisfred/u1db/u1todo-example-1 into lp:u1db

[Eric Casteleijn]

This has no UI yet, but is the bare bones back end of an application that will store todo items.

[Lucio Torre (lucio.torre)]

1- i am not comfortable with all init methods having side effects. This code for example looks strange:
27 + def test_indexes_are_added(self):
28 + """New indexes are added when a new store is created."""
29 + TodoStore(self.db)
30 + INDEXES['foo'] = ['bar']
31 + self.assertNotIn('foo', dict(self.db.list_indexes()))
32 + TodoStore(self.db)
33 + self.assertIn('foo', dict(self.db.list_indexes()))

Maybe we should have factories that create the objects.

2- There is no relation between the todoStore and the Tasks, which make me thing that there no need for the todo store. If we move to having no side effects on init, we could have store.get() and store.new() to produce the desired side effects.

[Eric Casteleijn (thisfred)]

suggested fixes applied

[lp:~thisfred/u1db/u1todo-example-1]

246. By Eric Casteleijn on 2012-04-18

refactored to remove side effects from init, and make store responsible for creating, getting and saving tasks.

247. By Eric Casteleijn on 2012-04-18

Took the initialization step out of the init.

248. By Eric Casteleijn on 2012-04-18

removed _trial_temp

[Lucio Torre (lucio.torre)]

review: Approve

=== added directory 'u1todo'
=== added file 'u1todo/__init__.py'
=== added directory 'u1todo/_trial_temp'
=== added directory 'u1todo/_trial_temp/xdg_cache'
=== added directory 'u1todo/_trial_temp/xdg_config'
=== added directory 'u1todo/_trial_temp/xdg_data'
=== added file 'u1todo/test_u1todo.py'
--- u1todo/test_u1todo.py	1970-01-01 00:00:00 +0000
+++ u1todo/test_u1todo.py	2012-04-18 20:45:23 +0000
@@ -0,0 +1,118 @@
+from testtools import TestCase
+from u1todo import Task, TodoStore, INDEXES, EMPTY_TASK, DONE, NOT_DONE
+from u1db.backends import inmemory
+
+
+class TodoStoreTestCase(TestCase):
+
+    def setUp(self):
+        super(TodoStoreTestCase, self).setUp()
+        self.db = inmemory.InMemoryDatabase("u1todo")
+
+    def test_initialize_db(self):
+        """Creates indexes."""
+        store = TodoStore(self.db)
+        store.initialize_db()
+        self.assertEqual(INDEXES, dict(self.db.list_indexes()))
+
+    def test_indexes_are_added(self):
+        """New indexes are added when a new store is created."""
+        store = TodoStore(self.db)
+        store.initialize_db()
+        INDEXES['foo'] = ['bar']
+        self.assertNotIn('foo', dict(self.db.list_indexes()))
+        store = TodoStore(self.db)
+        store.initialize_db()
+        self.assertIn('foo', dict(self.db.list_indexes()))
+
+    def test_indexes_are_updated(self):
+        """Indexes are updated when a new store is created."""
+        store = TodoStore(self.db)
+        store.initialize_db()
+        new_expression = ['newtags']
+        INDEXES['tags'] = new_expression
+        self.assertNotEqual(
+            new_expression, dict(self.db.list_indexes())['tags'])
+        store = TodoStore(self.db)
+        store.initialize_db()
+        self.assertEqual(new_expression, dict(self.db.list_indexes())['tags'])
+
+    def test_tag_task(self):
+        """Sets the tags for a task."""
+        store = TodoStore(self.db)
+        task = store.new_task()
+        tag = "you're it"
+        store.tag_task(task, [tag])
+        self.assertEqual([tag], task.tags)
+
+    def test_new_task(self):
+        """Creates a new task."""
+        store = TodoStore(self.db)
+        task = store.new_task()
+        self.assertTrue(isinstance(task, Task))
+        self.assertIsNotNone(task.document.doc_id)
+
+    def test_save_task_get_task(self):
+        """Saves a modified task and retrieves it from the db."""
+        store = TodoStore(self.db)
+        task = store.new_task()
+        task.title = "This is the title."
+        store.save_task(task)
+        task_copy = store.get_task(task.document.doc_id)
+        self.assertEqual(task.title, task_copy.title)
+
+
+class TaskTestCase(TestCase):
+    """Tests for Task."""
+
+    def setUp(self):
+        super(TaskTestCase, self).setUp()
+        self.db = inmemory.InMemoryDatabase("u1todo")
+        self.document = self.db.create_doc(EMPTY_TASK)
+
+    def test_task(self):
+        """Initializing a task."""
+        task = Task(self.document)
+        self.assertEqual("", task.title)
+        self.assertEqual([], task.tags)
+        self.assertEqual(False, task.done)
+
+    def test_set_title(self):
+        """Changing the title is persistent."""
+        task = Task(self.document)
+        title = "new task"
+        task.title = title
+        self.assertEqual(title, task._content['title'])
+
+    def test_set_done(self):
+        """Changing the done property changes the underlying content."""
+        task = Task(self.document)
+        self.assertEqual(NOT_DONE, task._content['done'])
+        task.done = True
+        self.assertEqual(DONE, task._content['done'])
+
+    def test_tags(self):
+        """Tags property returns a list."""
+        task = Task(self.document)
+        self.assertEqual([], task.tags)
+
+    def set_tags(self):
+        """Setting the tags property changes the underlying content."""
+        task = Task(self.document)
+        task.tags = ["foo", "bar"]
+        self.assertEqual(["foo", "bar"], task._content['tags'])
+
+    def test_add_tag(self):
+        """Tag is added to task's tags."""
+        task = Task(self.document)
+        task.add_tag("foo")
+        self.assertEqual(["foo"], task.tags)
+
+    def test_remove_tag(self):
+        """Tag is removed from task's tags."""
+        task = Task(self.document)
+        task.add_tag("foo")
+        task.add_tag("bar")
+        self.assertEqual(["foo", "bar"], task.tags)
+        task.remove_tag("foo")
+        self.assertEqual(["bar"], task.tags)

=== added file 'u1todo/u1todo.py'
--- u1todo/u1todo.py	1970-01-01 00:00:00 +0000
+++ u1todo/u1todo.py	2012-04-18 20:45:23 +0000
@@ -0,0 +1,111 @@
+import json
+
+DONE = 'true'
+NOT_DONE = 'false'
+
+EMPTY_TASK = json.dumps({"title": "", "done": NOT_DONE, "tags": []})
+
+INDEXES = {
+    'tags': ['tags'],
+    'done': ['done'],
+}
+
+
+class TodoStore(object):
+    """The todo application backend."""
+
+    def __init__(self, db):
+        self.db = db
+
+    def initialize_db(self):
+        db_indexes = dict(self.db.list_indexes())
+        for name, expression in INDEXES.items():
+            if name not in db_indexes:
+                # The index does not yet exist.
+                self.db.create_index(name, expression)
+                continue
+            if expression == db_indexes[name]:
+                # The index exists and is up to date.
+                continue
+            # The index exists but the definition is out of date.
+            self.db.delete_index(name)
+            self.db.create_index(name, expression)
+
+    def tag_task(self, task, tags):
+        """Set the tags of a task."""
+        task.tags = tags
+
+    def get_task(self, task_id):
+        """Get a task from the database."""
+        document = self.db.get_doc(task_id)
+        if document is None:
+            raise KeyError("No task with id '%s'." % (task_id,))
+        return Task(document)
+
+    def new_task(self):
+        document = self.db.create_doc(content=EMPTY_TASK)
+        return Task(document)
+
+    def save_task(self, task):
+        """Save task to the database."""
+        self.db.put_doc(task.document)
+
+
+class Task(object):
+    """A todo item."""
+
+    def __init__(self, document):
+        self._document = document
+        self._content = json.loads(document.content)
+
+    def _get_title(self):
+        """Get the task title."""
+        return self._content['title']
+
+    def _set_title(self, title):
+        """Set the task title and save to db."""
+        self._content['title'] = title
+
+    title = property(_get_title, _set_title, doc="Title of the task.")
+
+    def _get_done(self):
+        """Get the status of the task."""
+        # Indexes on booleans are not currently possible, so we convert to and
+        # from strings.
+        return True if self._content['done'] == DONE else False
+
+    def _set_done(self, value):
+        # Indexes on booleans are not currently possible, so we convert to and
+        # from strings.
+        self._content['done'] = DONE if value else NOT_DONE
+
+    done = property(_get_done, _set_done, doc="Done flag.")
+
+    def _get_tags(self):
+        """Get tags associated with the task."""
+        return self._content['tags']
+
+    def _set_tags(self, tags):
+        self._content['tags'] = list(set(tags))
+
+    tags = property(_get_tags, _set_tags, doc="Task tags.")
+
+    def add_tag(self, tag):
+        tags = self._content['tags']
+        if tag in tags:
+            # Tasks cannot have the same tag more than once, so ignore the
+            # request to add it again.
+            return
+        tags.append(tag)
+
+    def remove_tag(self, tag):
+        tags = self._content['tags']
+        if tag not in tags:
+            # Can't remove a tag that the task does not have.
+            raise KeyError("Task has no tag '%s'." % (tag,))
+        tags.remove(tag)
+
+    @property
+    def document(self):
+        self._document.content = json.dumps(self._content)
+        return self._document