Tests: Add tests for serializing annotations

[etc/taskwarrior.git] / tasklib / task.py

diff --git a/tasklib/task.py b/tasklib/task.py
index 1ab63479d96e140873730c2a39a5eea345627a78..d386f82faf32cd7e1152afc2d884e6aa82e646dc 100644 (file)
--- a/tasklib/task.py
+++ b/tasklib/task.py
@@ -5,6 +5,7 @@ import json
 import logging
 import os
 import six
 import logging
 import os
 import six

+import sys

 import subprocess
 
 DATE_FORMAT = '%Y%m%dT%H%M%SZ'
 import subprocess
 
 DATE_FORMAT = '%Y%m%dT%H%M%SZ'


@@ -28,6 +29,18 @@ class SerializingObject(object):
     """
     Common ancestor for TaskResource & TaskFilter, since they both
     need to serialize arguments.
     """
     Common ancestor for TaskResource & TaskFilter, since they both
     need to serialize arguments.

+
+    Serializing method should hold the following contract:
+      - any empty value (meaning removal of the attribute)
+        is deserialized into a empty string
+      - None denotes a empty value for any attribute
+
+    Deserializing method should hold the following contract:
+      - None denotes a empty value for any attribute (however,
+        this is here as a safeguard, TaskWarrior currently does
+        not export empty-valued attributes) if the attribute
+        is not iterable (e.g. list or set), in which case
+        a empty iterable should be used.

     """
 
     def _deserialize(self, key, value):
     """
 
     def _deserialize(self, key, value):


@@ -42,7 +55,7 @@ class SerializingObject(object):
 
     def timestamp_serializer(self, date):
         if not date:
 
     def timestamp_serializer(self, date):
         if not date:

-            return None
+            return ''

         return date.strftime(DATE_FORMAT)
 
     def timestamp_deserializer(self, date_str):
         return date.strftime(DATE_FORMAT)
 
     def timestamp_deserializer(self, date_str):


@@ -86,6 +99,15 @@ class SerializingObject(object):
     def deserialize_wait(self, value):
         return self.timestamp_deserializer(value)
 
     def deserialize_wait(self, value):
         return self.timestamp_deserializer(value)
 

+    def serialize_annotations(self, value):
+        value = value if value is not None else []
+        serialized_annotations = [annotation.export_data() for annotation in value]
+
+        if serialized_annotations:
+            return '[' + ','.join(serialized_annotations) + ']'
+        else:
+            return ''
+

     def deserialize_annotations(self, data):
         return [TaskAnnotation(self, d) for d in data] if data else []
 
     def deserialize_annotations(self, data):
         return [TaskAnnotation(self, d) for d in data] if data else []
 


@@ -97,9 +119,10 @@ class SerializingObject(object):
             return tags.split(',') if tags else []
         return tags or []
 
             return tags.split(',') if tags else []
         return tags or []
 

-    def serialize_depends(self, cur_dependencies):
+    def serialize_depends(self, value):

         # Return the list of uuids
         # Return the list of uuids

-        return ','.join(task['uuid'] for task in cur_dependencies)
+        value = value if value is not None else set()
+        return ','.join(task['uuid'] for task in value)

 
     def deserialize_depends(self, raw_uuids):
         raw_uuids = raw_uuids or ''  # Convert None to empty string
 
     def deserialize_depends(self, raw_uuids):
         raw_uuids = raw_uuids or ''  # Convert None to empty string


@@ -158,6 +181,40 @@ class TaskResource(SerializingObject):
     def __repr__(self):
         return str(self)
 
     def __repr__(self):
         return str(self)
 

+    def export_data(self):
+        """
+        Exports current data contained in the Task as JSON
+        """
+
+        # We need to remove spaces for TW-1504, use custom separators
+        data_tuples = ((key, self._serialize(key, value))
+                       for key, value in six.iteritems(self._data))
+
+        # Empty string denotes empty serialized value, we do not want
+        # to pass that to TaskWarrior.
+        data_tuples = filter(lambda t: t[1] is not '', data_tuples)
+        data = dict(data_tuples)
+        return json.dumps(data, separators=(',',':'))
+
+    @property
+    def _modified_fields(self):
+        writable_fields = set(self._data.keys()) - set(self.read_only_fields)
+        for key in writable_fields:
+            new_value = self._data.get(key)
+            old_value = self._original_data.get(key)
+
+            # Make sure not to mark data removal as modified field if the
+            # field originally had some empty value
+            if key in self._data and not new_value and not old_value:
+                continue
+
+            if new_value != old_value:
+                yield key
+
+    @property
+    def modified(self):
+        return bool(list(self._modified_fields))
+

 
 class TaskAnnotation(TaskResource):
     read_only_fields = ['entry', 'description']
 
 class TaskAnnotation(TaskResource):
     read_only_fields = ['entry', 'description']


@@ -205,6 +262,40 @@ class Task(TaskResource):
         """
         pass
 
         """
         pass
 

+    @classmethod
+    def from_input(cls, input_file=sys.stdin, modify=None):
+        """
+        Creates a Task object, directly from the stdin, by reading one line.
+        If modify=True, two lines are used, first line interpreted as the
+        original state of the Task object, and second line as its new,
+        modified value. This is consistent with the TaskWarrior's hook
+        system.
+
+        Object created by this method should not be saved, deleted
+        or refreshed, as t could create a infinite loop. For this
+        reason, TaskWarrior instance is set to None.
+
+        Input_file argument can be used to specify the input file,
+        but defaults to sys.stdin.
+        """
+
+        # TaskWarrior instance is set to None
+        task = cls(None)
+
+        # Detect the hook type if not given directly
+        name = os.path.basename(sys.argv[0])
+        modify = name.startswith('on-modify') if modify is None else modify
+
+        # Load the data from the input
+        task._load_data(json.loads(input_file.readline().strip()))
+
+        # If this is a on-modify event, we are provided with additional
+        # line of input, which provides updated data
+        if modify:
+            task._update_data(json.loads(input_file.readline().strip()))
+
+        return task
+

     def __init__(self, warrior, **kwargs):
         self.warrior = warrior
 
     def __init__(self, warrior, **kwargs):
         self.warrior = warrior
 


@@ -241,17 +332,6 @@ class Task(TaskResource):
             # If the tasks are not saved, return hash of instance id
             return id(self).__hash__()
 
             # If the tasks are not saved, return hash of instance id
             return id(self).__hash__()
 

-    @property
-    def _modified_fields(self):
-        writable_fields = set(self._data.keys()) - set(self.read_only_fields)
-        for key in writable_fields:
-            if self._data.get(key) != self._original_data.get(key):
-                yield key
-
-    @property
-    def _is_modified(self):
-        return bool(list(self._modified_fields))
-

     @property
     def completed(self):
         return self['status'] == six.text_type('completed')
     @property
     def completed(self):
         return self['status'] == six.text_type('completed')


@@ -274,7 +354,7 @@ class Task(TaskResource):
 
     def serialize_depends(self, cur_dependencies):
         # Check that all the tasks are saved
 
     def serialize_depends(self, cur_dependencies):
         # Check that all the tasks are saved

-        for task in cur_dependencies:
+        for task in (cur_dependencies or set()):

             if not task.saved:
                 raise Task.NotSaved('Task \'%s\' needs to be saved before '
                                     'it can be set as dependency.' % task)
             if not task.saved:
                 raise Task.NotSaved('Task \'%s\' needs to be saved before '
                                     'it can be set as dependency.' % task)


@@ -342,7 +422,7 @@ class Task(TaskResource):
         self.refresh(only_fields=['status'])
 
     def save(self):
         self.refresh(only_fields=['status'])
 
     def save(self):

-        if self.saved and not self._is_modified:
+        if self.saved and not self.modified:

             return
 
         args = [self['uuid'], 'modify'] if self.saved else ['add']
             return
 
         args = [self['uuid'], 'modify'] if self.saved else ['add']


@@ -362,6 +442,9 @@ class Task(TaskResource):
             # Circumvent the ID storage, since ID is considered read-only
             self._data['id'] = int(id_lines[0].split(' ')[2].rstrip('.'))
 
             # Circumvent the ID storage, since ID is considered read-only
             self._data['id'] = int(id_lines[0].split(' ')[2].rstrip('.'))
 

+        # Refreshing is very important here, as not only modification time
+        # is updated, but arbitrary attribute may have changed due hooks
+        # altering the data before saving

         self.refresh()
 
     def add_annotation(self, annotation):
         self.refresh()
 
     def add_annotation(self, annotation):


@@ -388,13 +471,21 @@ class Task(TaskResource):
         def add_field(field):
             # Add the output of format_field method to args list (defaults to
             # field:value)
         def add_field(field):
             # Add the output of format_field method to args list (defaults to
             # field:value)

-            serialized_value = self._serialize(field, self._data[field]) or ''
-            format_default = lambda: "{0}:{1}".format(
-                field,
-                "'{0}'".format(serialized_value) if serialized_value else ''
-            )
+            serialized_value = self._serialize(field, self._data[field])
+
+            # Empty values should not be enclosed in quotation marks, see
+            # TW-1510
+            if serialized_value is '':
+                escaped_serialized_value = ''
+            else:
+                escaped_serialized_value = "'{0}'".format(serialized_value)
+
+            format_default = lambda: "{0}:{1}".format(field,
+                                                      escaped_serialized_value)
+

             format_func = getattr(self, 'format_{0}'.format(field),
                                   format_default)
             format_func = getattr(self, 'format_{0}'.format(field),
                                   format_default)

+

             args.append(format_func())
 
         # If we're modifying saved task, simply pass on all modified fields
             args.append(format_func())
 
         # If we're modifying saved task, simply pass on all modified fields


@@ -427,7 +518,6 @@ class Task(TaskResource):
         else:
             self._load_data(new_data)
 
         else:
             self._load_data(new_data)
 

-

 class TaskFilter(SerializingObject):
     """
     A set of parameters to filter the task list with.
 class TaskFilter(SerializingObject):
     """
     A set of parameters to filter the task list with.


@@ -589,7 +679,8 @@ class TaskWarrior(object):
         self.config = {
             'data.location': os.path.expanduser(data_location),
             'confirmation': 'no',
         self.config = {
             'data.location': os.path.expanduser(data_location),
             'confirmation': 'no',

-            'dependency.confirmation': 'no', # See TW-1483 or taskrc man page
+            'dependency.confirmation': 'no',  # See TW-1483 or taskrc man page
+            'recurrence.confirmation': 'no',  # Necessary for modifying R tasks

         }
         self.tasks = TaskQuerySet(self)
         self.version = self._get_version()
         }
         self.tasks = TaskQuerySet(self)
         self.version = self._get_version()