Merge lp:~thisfred/u1db/u1todo-4 into lp:u1db

[Eric Casteleijn]

This adds tags.

to test, run PYTHONPATH=. python u1todo/ui.py

tags are whitespace separated strings starting with #, or anything between []s (Not being able to use whitespace in tags is a pet peeve of mine, this will allow it, while forcing no one to use it.)

[dobey (dobey)]

review: Approve

[Roberto Alsina (ralsina)]

Works!

The use of buttons for the tag column feels weird. The traditional solution would be a list with checkmarks. That would look quite like the task list, which is not good either. Maybe we could use highly stilized buttons instead, to make them look like colored labels (think github's issue page: http://bit.ly/KDmeNg)

Also, I see no way to visually represent what is the meaning of multiple "ON" tags: is it
"and" or "or"? Do we care?

OTOH, nothing wrong in the code. So, this just needs some serious design thought.

review: Needs Information

[Eric Casteleijn (thisfred)]

Stylized buttons were exactly what I was thinking, since that is how a lot of (web) apps represent tags. I have chosen multiple selections to mean AND, but I could be convinced to make it or. Ideally both would be possible. Not hard to do in code, but far from easy to represent in an intuitive way in the UI.

[Roberto Alsina (ralsina)]

+1 it is then

review: Approve

=== modified file 'u1db/__init__.py'
--- u1db/__init__.py	2012-04-30 11:19:18 +0000
+++ u1db/__init__.py	2012-05-04 20:17:19 +0000
@@ -185,13 +185,13 @@
     def get_from_index(self, index_name, key_values):
         """Return documents that match the keys supplied.
 
-        You must supply exactly the same number of values as the index has been
-        defined. It is possible to do a prefix match by using '*' to indicate a
-        wildcard match. You can only supply '*' to trailing entries, (eg
-        [('val', '*', '*')] is allowed, but [('*', 'val', 'val')] is not.)
+        You must supply exactly the same number of values as has been defined
+        in the index. It is possible to do a prefix match by using '*' to
+        indicate a wildcard match. You can only supply '*' to trailing entries,
+        (eg [('val', '*', '*')] is allowed, but [('*', 'val', 'val')] is not.)
         It is also possible to append a '*' to the last supplied value (eg
-        [('val*', '*', '*')] or [('val', 'val*', '*')], but not
-        [('val*', 'val', '*')])
+        [('val*', '*', '*')] or [('val', 'val*', '*')], but not [('val*',
+        'val', '*')])
 
         :return: List of [Document]
         :param index_name: The index to query

=== modified file 'u1todo/test_u1todo.py'
--- u1todo/test_u1todo.py	2012-04-23 20:44:10 +0000
+++ u1todo/test_u1todo.py	2012-05-04 20:17:19 +0000
@@ -17,7 +17,8 @@
 """Tests for u1todo example application."""
 
 from testtools import TestCase
-from u1todo import Task, TodoStore, INDEXES, EMPTY_TASK, DONE, NOT_DONE
+from u1todo import (
+    Task, TodoStore, INDEXES, TAGS_INDEX, EMPTY_TASK, extract_tags)
 from u1db.backends import inmemory
 
 
@@ -55,13 +56,62 @@
         store = TodoStore(self.db)
         store.initialize_db()
         new_expression = ['newtags']
-        INDEXES['tags'] = new_expression
+        INDEXES[TAGS_INDEX] = 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_get_all_tags(self):
+        store = TodoStore(self.db)
+        store.initialize_db()
+        tags = ['foo', 'bar', 'bam']
+        task = store.new_task(tags=tags)
+        self.assertEqual(sorted(tags), sorted(store.get_all_tags()))
+        tags = ['foo', 'sball']
+        task.tags = tags
+        store.save_task(task)
+        self.assertEqual(sorted(tags), sorted(store.get_all_tags()))
+
+    def test_get_all_tags_duplicates(self):
+        store = TodoStore(self.db)
+        store.initialize_db()
+        tags = ['foo', 'bar', 'bam']
+        store.new_task(tags=tags)
+        self.assertEqual(sorted(tags), sorted(store.get_all_tags()))
+        tags2 = ['foo', 'sball']
+        store.new_task(tags=tags2)
+        self.assertEqual(set(tags + tags2), set(store.get_all_tags()))
+
+    def test_get_tasks_by_tags(self):
+        store = TodoStore(self.db)
+        store.initialize_db()
+        tags = ['foo', 'bar', 'bam']
+        task1 = store.new_task(tags=tags)
+        tags2 = ['foo', 'sball']
+        task2 = store.new_task(tags=tags2)
+        self.assertEqual(
+            sorted([task1.task_id, task2.task_id]),
+            sorted([t.task_id for t in store.get_tasks_by_tags(['foo'])]))
+        self.assertEqual(
+            [task1.task_id],
+            [t.task_id for t in store.get_tasks_by_tags(['foo', 'bar'])])
+        self.assertEqual(
+            [task2.task_id],
+            [t.task_id for t in store.get_tasks_by_tags(['foo', 'sball'])])
+
+    def test_get_tasks_by_empty_tags(self):
+        store = TodoStore(self.db)
+        store.initialize_db()
+        tags = ['foo', 'bar', 'bam']
+        task1 = store.new_task(tags=tags)
+        tags2 = ['foo', 'sball']
+        task2 = store.new_task(tags=tags2)
+        self.assertEqual(
+            sorted([task1.task_id, task2.task_id]),
+            sorted([t.task_id for t in store.get_tasks_by_tags([])]))
+
     def test_tag_task(self):
         """Sets the tags for a task."""
         store = TodoStore(self.db)
@@ -154,9 +204,14 @@
     def test_set_done(self):
         """Changing the done property changes the underlying content."""
         task = Task(self.document)
-        self.assertEqual(NOT_DONE, task._content['done'])
+        self.assertEqual(False, task._content['done'])
         task.done = True
-        self.assertEqual(DONE, task._content['done'])
+        self.assertEqual(True, task._content['done'])
+
+    def test_extracts_tags(self):
+        """Tags are extracted from the item's text."""
+        title = "#buy beer at [liquor store]"
+        self.assertEqual(['buy', 'liquor store'], sorted(extract_tags(title)))
 
     def test_tags(self):
         """Tags property returns a list."""
@@ -168,18 +223,3 @@
         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)

=== modified file 'u1todo/u1todo.py'
--- u1todo/u1todo.py	2012-04-27 14:24:05 +0000
+++ u1todo/u1todo.py	2012-05-04 20:17:19 +0000
@@ -18,19 +18,21 @@
 
 import json
 import os
+import re
 import xdg.BaseDirectory
 from u1db.backends.sqlite_backend import SQLitePartialExpandDatabase
 
-DONE = 'true'
-NOT_DONE = 'false'
-
-EMPTY_TASK = json.dumps({"title": "", "done": NOT_DONE, "tags": []})
-
+EMPTY_TASK = json.dumps({"title": "", "done": False, "tags": []})
+
+TAGS_INDEX = 'tags'
+DONE_INDEX = 'done'
 INDEXES = {
-    'tags': ['tags'],
-    'done': ['done'],
+    TAGS_INDEX: ['tags'],
+    DONE_INDEX: ['bool(done)'],
 }
 
+TAGS = re.compile('#(\w+)|\[(.+)\]')
+
 
 def get_database():
     """Get the path that the database is stored in."""
@@ -40,6 +42,11 @@
         "u1todo.u1db"))
 
 
+def extract_tags(text):
+    """Extract the tags from the text."""
+    return [t[0] if t[0] else t[1] for t in TAGS.findall(text)]
+
+
 class TodoStore(object):
     """The todo application backend."""
 
@@ -65,6 +72,27 @@
         """Set the tags of a task."""
         task.tags = tags
 
+    def get_all_tags(self):
+        """Get all the tags in use."""
+        return self.db.get_index_keys(TAGS_INDEX)
+
+    def get_tasks_by_tags(self, tags):
+        if not tags:
+            return self.get_all_tasks()
+        results = {
+            doc.doc_id: doc for doc in
+            self.db.get_from_index(TAGS_INDEX, [(tags[0],)])}
+        for tag in tags[1:]:
+            ids = [
+                doc.doc_id for doc in
+                self.db.get_from_index(TAGS_INDEX, [(tag,)])]
+            for key in results.keys():
+                if key not in ids:
+                    del results[key]
+                    if not results:
+                        return []
+        return [Task(doc) for doc in results.values()]
+
     def get_task(self, task_id):
         """Get a task from the database."""
         document = self.db.get_doc(task_id)
@@ -81,6 +109,8 @@
     def new_task(self, title=None, tags=None):
         """Create a new task document."""
         # Create the document in the u1db database
+        if tags is None:
+            tags = []
         content = EMPTY_TASK
         if title or tags:
             content_object = json.loads(content)
@@ -99,7 +129,7 @@
 
     def get_all_tasks(self):
         return [
-            Task(doc) for doc in self.db.get_from_index("done", ["*"])]
+            Task(doc) for doc in self.db.get_from_index(DONE_INDEX, ["*"])]
 
 
 class Task(object):
@@ -126,16 +156,11 @@
 
     def _get_done(self):
         """Get the status of the task."""
-        # Indexes on booleans are not currently possible, so we convert to and
-        # from strings. TODO: LP #987412
-        return True if self._content['done'] == DONE else False
+        return self._content['done']
 
     def _set_done(self, value):
         """Set the done status."""
-        # Indexes on booleans are not currently possible, so we convert to and
-        # from strings.
-        # from strings. TODO: LP #987412
-        self._content['done'] = DONE if value else NOT_DONE
+        self._content['done'] = value
 
     done = property(_get_done, _set_done, doc="Done flag.")
 
@@ -149,23 +174,6 @@
 
     tags = property(_get_tags, _set_tags, doc="Task tags.")
 
-    def add_tag(self, tag):
-        """Add a single tag to the task."""
-        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):
-        """Remove a single tag from the task."""
-        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):
         """The u1db document representing this task."""

=== modified file 'u1todo/u1todo.ui'
--- u1todo/u1todo.ui	2012-04-20 13:56:35 +0000
+++ u1todo/u1todo.ui	2012-05-04 20:17:19 +0000
@@ -6,7 +6,7 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>334</width>
+    <width>408</width>
     <height>834</height>
    </rect>
   </property>
@@ -14,28 +14,49 @@
    <string>MainWindow</string>
   </property>
   <widget class="QWidget" name="centralwidget">
-   <layout class="QVBoxLayout" name="verticalLayout">
+   <layout class="QHBoxLayout" name="horizontalLayout_2">
     <item>
-     <widget class="QListWidget" name="list_widget"/>
+     <layout class="QVBoxLayout" name="verticalLayout">
+      <item>
+       <widget class="QListWidget" name="todo_list"/>
+      </item>
+      <item>
+       <widget class="QLineEdit" name="task_edit"/>
+      </item>
+      <item>
+       <layout class="QHBoxLayout" name="horizontalLayout">
+        <item>
+         <widget class="QPushButton" name="edit_button">
+          <property name="text">
+           <string>Add/&amp;Edit</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QPushButton" name="delete_button">
+          <property name="text">
+           <string>&amp;Delete</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+     </layout>
     </item>
     <item>
-     <layout class="QHBoxLayout" name="horizontalLayout">
-      <item>
-       <widget class="QLineEdit" name="line_edit"/>
-      </item>
-      <item>
-       <widget class="QPushButton" name="edit_button">
-        <property name="text">
-         <string>Add/Edit</string>
-        </property>
-       </widget>
-      </item>
-      <item>
-       <widget class="QPushButton" name="delete_button">
-        <property name="text">
-         <string>Delete</string>
-        </property>
-       </widget>
+     <layout class="QVBoxLayout" name="tag_buttons">
+      <item>
+       <spacer name="verticalSpacer">
+        <property name="orientation">
+         <enum>Qt::Vertical</enum>
+        </property>
+        <property name="sizeHint" stdset="0">
+         <size>
+          <width>20</width>
+          <height>40</height>
+         </size>
+        </property>
+       </spacer>
       </item>
      </layout>
     </item>
@@ -46,13 +67,19 @@
     <rect>
      <x>0</x>
      <y>0</y>
-     <width>334</width>
+     <width>408</width>
      <height>21</height>
     </rect>
    </property>
   </widget>
   <widget class="QStatusBar" name="statusbar"/>
  </widget>
+ <tabstops>
+  <tabstop>task_edit</tabstop>
+  <tabstop>edit_button</tabstop>
+  <tabstop>delete_button</tabstop>
+  <tabstop>todo_list</tabstop>
+ </tabstops>
  <resources/>
  <connections/>
 </ui>

=== modified file 'u1todo/ui.py'
--- u1todo/ui.py	2012-04-23 20:44:10 +0000
+++ u1todo/ui.py	2012-05-04 20:17:19 +0000
@@ -16,7 +16,8 @@
 
 """User interface for the u1todo example application."""
 
-from u1todo import TodoStore, get_database
+from u1todo import TodoStore, get_database, extract_tags
+from collections import defaultdict
 import os
 import sys
 from PyQt4 import QtGui, QtCore, uic
@@ -41,21 +42,36 @@
         uifile = os.path.join(os.path.abspath(os.path.dirname(__file__)),
                               'u1todo.ui')
         uic.loadUi(uifile, self)
+        self.connect_events()
         db = get_database()
         self.store = TodoStore(db)
+        # create or update the indexes if they are not up-to-date
         self.store.initialize_db()
-        self.connect_events()
-        self.item = None
         self.delete_button.setEnabled(False)
+        self._tag_docs = defaultdict(list)
+        self._tag_buttons = {}
+        self._tag_filter = []
         for task in self.store.get_all_tasks():
             self.add_task(task)
+        self.task_edit.clear()
+        self.task_edit.setFocus()
+        self.item = None
 
     def connect_events(self):
         """Hook up all the signal handlers."""
+        self.task_edit.returnPressed.connect(self.update)
         self.edit_button.clicked.connect(self.update)
         self.delete_button.clicked.connect(self.delete)
-        self.list_widget.currentRowChanged.connect(self.row_changed)
-        self.list_widget.itemChanged.connect(self.item_changed)
+        self.todo_list.currentRowChanged.connect(self.row_changed)
+        self.todo_list.itemChanged.connect(self.item_changed)
+
+    def refresh_filter(self):
+        while len(self.todo_list):
+            self.todo_list.takeItem(0)
+        for task in self.store.get_tasks_by_tags(self._tag_filter):
+            self.add_task(task)
+        self.item = None
+        self.task_edit.clear()
 
     def item_changed(self, item):
         if item.checkState() == QtCore.Qt.Checked:
@@ -63,54 +79,103 @@
         else:
             item.task.done = False
         self.store.save_task(item.task)
+        self.todo_list.setCurrentRow(-1)
+        self.task_edit.clear()
+        self.item = None
 
     def update(self):
         """Either add a new task or update an existing one."""
-        text = unicode(self.line_edit.text(), 'utf-8')
+        text = unicode(self.task_edit.text(), 'utf-8')
         if not text:
             return
         if self.item is None:
-            task = self.store.new_task(text)
+            task = self.store.new_task(text, tags=extract_tags(text))
             self.add_task(task)
         else:
             self.update_task_text(text)
-        self.line_edit.clear()
+        self.todo_list.setCurrentRow(-1)
+        self.task_edit.clear()
         self.item = None
 
     def delete(self):
         """Delete a todo item."""
-        item = self.list_widget.takeItem(self.list_widget.currentRow())
+        item = self.todo_list.takeItem(self.todo_list.currentRow())
         self.store.delete_task(item.task)
-        if self.list_widget.count() == 0:
+        self.todo_list.setCurrentRow(-1)
+        if self.todo_list.count() == 0:
             self.delete_button.setEnabled(False)
 
     def add_task(self, task):
         """Add a new todo item."""
         item = UITask(task)
-        self.list_widget.addItem(item)
+        self.todo_list.addItem(item)
         self.delete_button.setEnabled(True)
+        if not task.tags:
+            return
+        for tag in task.tags:
+            self.add_tag(task.task_id, tag)
+
+    def add_tag(self, task_id, tag):
+        self._tag_docs[tag].append(task_id)
+        if len(self._tag_docs[tag]) > 1:
+            return
+        button = QtGui.QPushButton(tag)
+        button._u1todo_tag = tag
+        button.setCheckable(True)
+        self._tag_buttons[tag] = button
+
+        def filter_toggle(checked):
+            if checked:
+                self._tag_filter.append(button._u1todo_tag)
+            else:
+                self._tag_filter.remove(button._u1todo_tag)
+            self.refresh_filter()
+
+        button.clicked.connect(filter_toggle)
+        index = sorted(self._tag_buttons.keys()).index(tag)
+        self.tag_buttons.insertWidget(index, button)
+
+    def remove_tag(self, task_id, tag):
+        self._tag_docs[tag].remove(task_id)
+        if self._tag_docs[tag]:
+            return
+        button = self._tag_buttons[tag]
+        self.tag_buttons.removeWidget(button)
+        del self._tag_buttons[tag]
+
+    def update_tags(self, task_id, old_tags, new_tags):
+        for tag in old_tags - new_tags:
+            self.remove_tag(task_id, tag)
+        for tag in new_tags - old_tags:
+            self.add_tag(task_id, tag)
 
     def update_task_text(self, text):
         """Edit an existing todo item."""
-        self.item.task.title = text
+        item = self.item
+        task = item.task
+        task.title = text
+        old_tags = set(task.tags) if task.tags else set([])
+        new_tags = set(extract_tags(text))
+        self.update_tags(item.task.task_id, old_tags, new_tags)
+        task.tags = list(new_tags)
         # disconnect the signal temporarily while we change the title
-        self.list_widget.itemChanged.disconnect(self.item_changed)
-        self.item.setText(text)
+        self.todo_list.itemChanged.disconnect(self.item_changed)
+        item.setText(text)
         # reconnect the signal after we changed the title
-        self.list_widget.itemChanged.connect(self.item_changed)
-        self.store.save_task(self.item.task)
+        self.todo_list.itemChanged.connect(self.item_changed)
+        self.store.save_task(task)
 
     def row_changed(self, index):
         """Edit item when row changes."""
         if index == -1:
-            self.line_edit.clear()
+            self.task_edit.clear()
             return
-        self.edit_item(self.list_widget.item(index))
+        self.edit_item(self.todo_list.item(index))
 
     def edit_item(self, item):
-        """Edit item in line edit box."""
+        """Edit item in task edit box."""
         self.item = item
-        self.line_edit.setText(item.task.title)
+        self.task_edit.setText(item.task.title)
 
 
 if __name__ == "__main__":