]> git.madduck.net Git - etc/taskwarrior.git/blobdiff - tasklib/task.py

madduck's git repository

Every one of the projects in this repository is available at the canonical URL git://git.madduck.net/madduck/pub/<projectpath> — see each project's metadata for the exact URL.

All patches and comments are welcome. Please squash your changes to logical commits before using git-format-patch and git-send-email to patches@git.madduck.net. If you'd read over the Git project's submission guidelines and adhered to them, I'd be especially grateful.

SSH access, as well as push access can be individually arranged.

If you use my repositories frequently, consider adding the following snippet to ~/.gitconfig and using the third clone URL listed for each project:

[url "git://git.madduck.net/madduck/"]
  insteadOf = madduck:

Task: Use empty string as replacement for None when saving the task
[etc/taskwarrior.git] / tasklib / task.py
index 330491f65ed6ae4ee6e55db283f6379892e812c2..4377f1fb8f1737d730a7cb782c1a2d5f74ba3cd6 100644 (file)
@@ -29,8 +29,19 @@ class TaskResource(object):
 
     def _load_data(self, data):
         self._data = data
+        # We need to use a copy for original data, so that changes
+        # are not propagated
+        self._original_data = data.copy()
 
     def __getitem__(self, key):
+        # This is a workaround to make TaskResource non-iterable
+        # over simple index-based iteration
+        try:
+            int(key)
+            raise StopIteration
+        except ValueError:
+            pass
+
         hydrate_func = getattr(self, 'deserialize_{0}'.format(key),
                                lambda x: x)
         return hydrate_func(self._data.get(key))
@@ -41,7 +52,6 @@ class TaskResource(object):
         dehydrate_func = getattr(self, 'serialize_{0}'.format(key),
                                  lambda x: x)
         self._data[key] = dehydrate_func(value)
-        self._modified_fields.add(key)
 
     def __str__(self):
         s = six.text_type(self.__unicode__())
@@ -107,11 +117,33 @@ class Task(TaskResource):
         kwargs.update(data)
 
         self._load_data(kwargs)
-        self._modified_fields = set()
 
     def __unicode__(self):
         return self['description']
 
+    def __eq__(self, other):
+        if self['uuid'] and other['uuid']:
+            # For saved Tasks, just define equality by equality of uuids
+            return self['uuid'] == other['uuid']
+        else:
+            # If the tasks are not saved, compare the actual instances
+            return id(self) == id(other)
+
+
+    def __hash__(self):
+        if self['uuid']:
+            # For saved Tasks, just define equality by equality of uuids
+            return self['uuid'].__hash__()
+        else:
+            # If the tasks are not saved, return hash of instance id
+            return id(self).__hash__()
+
+    @property
+    def _modified_fields(self):
+        for key in self._data.keys():
+            if self._data.get(key) != self._original_data.get(key):
+                yield key
+
     @property
     def completed(self):
         return self['status'] == six.text_type('completed')
@@ -140,6 +172,41 @@ class Task(TaskResource):
             return None
         return datetime.datetime.strptime(date_str, DATE_FORMAT)
 
+    def serialize_depends(self, cur_dependencies):
+        # Check that all the tasks are saved
+        for task in cur_dependencies:
+            if not task.saved:
+                raise Task.NotSaved('Task \'%s\' needs to be saved before '
+                                    'it can be set as dependency.' % task)
+
+        # Return the list of uuids
+        return ','.join(task['uuid'] for task in cur_dependencies)
+
+    def deserialize_depends(self, raw_uuids):
+        raw_uuids = raw_uuids or ''  # Convert None to empty string
+        uuids = raw_uuids.split(',')
+        return set(self.warrior.tasks.get(uuid=uuid) for uuid in uuids if uuid)
+
+    def format_depends(self):
+        # We need to generate added and removed dependencies list,
+        # since Taskwarrior does not accept redefining dependencies.
+
+        # This cannot be part of serialize_depends, since we need
+        # to keep a list of all depedencies in the _data dictionary,
+        # not just currently added/removed ones
+
+        old_dependencies_raw = self._original_data.get('depends','')
+        old_dependencies = self.deserialize_depends(old_dependencies_raw)
+
+        added = self['depends'] - old_dependencies
+        removed = old_dependencies - self['depends']
+
+        # Removed dependencies need to be prefixed with '-'
+        return ','.join(
+                [t['uuid'] for t in added] +
+                ['-' + t['uuid'] for t in removed]
+            )
+
     def deserialize_annotations(self, data):
         return [TaskAnnotation(self, d) for d in data] if data else []
 
@@ -204,7 +271,6 @@ class Task(TaskResource):
             # Circumvent the ID storage, since ID is considered read-only
             self._data['id'] = int(id_lines[0].split(' ')[2].rstrip('.'))
 
-        self._modified_fields.clear()
         self.refresh()
 
     def add_annotation(self, annotation):
@@ -233,8 +299,11 @@ class Task(TaskResource):
             # task description if description: prefix is used
             if self.warrior.version < VERSION_2_4_0 and field == 'description':
                 args.append(self._data[field])
+            elif field == 'depends':
+                args.append('{0}:{1}'.format(field, self.format_depends()))
             else:
-                args.append('{0}:{1}'.format(field, self._data[field]))
+                # Use empty string to substitute for None value
+                args.append('{0}:{1}'.format(field, self._data[field] or ''))
 
         # If we're modifying saved task, simply pass on all modified fields
         if self.saved:
@@ -263,8 +332,13 @@ class Task(TaskResource):
             to_update = dict(
                 [(k, new_data.get(k)) for k in only_fields])
             self._data.update(to_update)
+            self._original_data.update(to_update)
         else:
             self._data = new_data
+            # We need to create a clone for original_data though
+            # Shallow copy is alright, since data dict uses only
+            # primitive data types
+            self._original_data = new_data.copy()
 
 
 class TaskFilter(object):
@@ -284,7 +358,13 @@ class TaskFilter(object):
         # Replace the value with empty string, since that is the
         # convention in TW for empty values
         value = value if value is not None else ''
-        self.filter_params.append('{0}:{1}'.format(key, value))
+
+        # If we are filtering by uuid:, do not use uuid keyword
+        # due to TW-1452 bug
+        if key == 'uuid':
+            self.filter_params.insert(0, value)
+        else:
+            self.filter_params.append('{0}:{1}'.format(key, value))
 
     def get_filter_params(self):
         return [f for f in self.filter_params if f]