Rename dependency method done() to on_done()

on_done() is maybe a better choice, it is less ambiguous than then() (clearer
on the fact it happens on done()) and done() (less confusion with set_done()).
I'll do the renaming soon, unless you have other suggestions.

Ref: OCA#154 (comment)

Author: guewen

queue_job/controllers/main.py

@@ -270,7 +270,7 @@ def _create_graph_test_jobs(
                 root_delayable = delayable
             else:
                 tail_delayable = random.choice(tails)
-                tail_delayable.done(delayable)
+                tail_delayable.on_done(delayable)
             tails.append(delayable)
 
         root_delayable.delay()

queue_job/delay.py

@@ -27,7 +27,7 @@ def group(*delayables):
 
         g1 = group(delayable1, delayable2)
         g2 = group(delayable3, delayable4)
-        g1.done(g2)
+        g1.on_done(g2)
         g1.delay()
     """
     return DelayableGroup(*delayables)
@@ -46,7 +46,7 @@ def chain(*delayables):
 
         chain1 = chain(delayable1, delayable2, delayable3)
         chain2 = chain(delayable4, delayable5, delayable6)
-        chain1.done(chain2)
+        chain1.on_done(chain2)
         chain1.delay()
     """
     return DelayableChain(*delayables)
@@ -351,7 +351,7 @@ def __repr__(self):
         inner_graph = "\n\t".join(repr(self._graph).split("\n"))
         return 'DelayableChain(\n\t{}\n)'.format(inner_graph)
 
-    def done(self, *delayables):
+    def on_done(self, *delayables):
         """Connects the current chain to other delayables/chains/groups
 
         The delayables/chains/groups passed in the parameters will be executed
@@ -406,7 +406,7 @@ def __repr__(self):
         inner_graph = "\n\t".join(repr(self._graph).split("\n"))
         return 'DelayableGroup(\n\t{}\n)'.format(inner_graph)
 
-    def done(self, *delayables):
+    def on_done(self, *delayables):
         """Connects the current group to other delayables/chains/groups
 
         The delayables/chains/groups passed in the parameters will be executed
@@ -512,7 +512,7 @@ def set(self, *args, **kwargs):
         self._set_from_dict(kwargs)
         return self
 
-    def done(self, *delayables):
+    def on_done(self, *delayables):
         """Connects the current Delayable to other delayables/chains/groups
 
         The delayables/chains/groups passed in the parameters will be executed

queue_job/models/base.py

@@ -94,7 +94,7 @@ def delayable(self, priority=None, eta=None,
 
             job1 = record1.delayable().do_work()
             job2 = record2.delayable().do_work()
-            job1.done(job2)
+            job1.on_done(job2)
 
         The ``delay()`` call must be made on ``job1``, otherwise ``job2`` will
         be delayed, but ``job1`` will never be. When done on ``job1``, the

queue_job/readme/USAGE.rst

@@ -60,7 +60,7 @@ which in some cases allow to build the jobs dynamically:
             .delay()
         )
 
-The simplest way to define a dependency is to use ``.done(job)`` on a Delayable:
+The simplest way to define a dependency is to use ``.on_done(job)`` on a Delayable:
 
 .. code-block:: python
 
@@ -70,13 +70,13 @@ The simplest way to define a dependency is to use ``.done(job)`` on a Delayable:
         job2 = self.browse(1).delayable().generate_thumbnail((50, 50))
         job3 = self.browse(1).delayable().generate_thumbnail((50, 50))
         # job 3 is executed when job 2 is done which is executed when job 1 is done
-        job1.done(job2.done(job3)).delay()
+        job1.on_done(job2.on_done(job3)).delay()
 
 Delayables can be chained to form more complex graphs using the ``chain()`` and
 ``group()`` primitives.
 A chain represents a sequence of jobs to execute in order, a group represents
 jobs which can be executed in parallel. Using ``chain()`` has the same effect as
-using several nested ``done()`` but is more readable. Both can be combined to
+using several nested ``on_done()`` but is more readable. Both can be combined to
 form a graph, for instance we can group [A] of jobs, which blocks another group
 [B] of jobs. When and only when all the jobs of the group [A] are executed, the
 jobs of the group [B] are executed. The code would look like:

queue_job/tests/test_delayable.py

@@ -62,9 +62,9 @@ def test_graph_connect(self):
         node_tail2 = Delayable(self.recordset)
         node_middle = Delayable(self.recordset)
         node_top = Delayable(self.recordset)
-        node_middle.done(node_tail)
-        node_middle.done(node_tail2)
-        node_top.done(node_middle)
+        node_middle.on_done(node_tail)
+        node_middle.on_done(node_tail2)
+        node_top.on_done(node_middle)
         collected = node_top._graph._connect_graphs()
         self.assertEqual(
             collected._graph,