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,

test_queue_job/tests/test_delay_mocks.py

@@ -73,8 +73,8 @@ def test_trap_jobs_perform(self):
             node = Delayable(model).create_ir_logging("test_trap_jobs_perform graph 1")
             node2 = Delayable(model).create_ir_logging("test_trap_jobs_perform graph 2")
             node3 = Delayable(model).create_ir_logging("test_trap_jobs_perform graph 3")
-            node2.done(node3)
-            node3.done(node)
+            node2.on_done(node3)
+            node3.on_done(node)
             node2.delay()
 
             # jobs are not executed
@@ -141,7 +141,7 @@ def test_delay_graph_direct_exec_env_var(self):
         node2 = Delayable(self.env["test.queue.job"]).create_ir_logging(
             "test_delay_graph_direct_exec 2"
         )
-        node2.done(node)
+        node2.on_done(node)
         node2.delay()
         # jobs are executed directly
         logs = self.env["ir.logging"].search(
@@ -168,7 +168,7 @@ def test_delay_graph_direct_exec_context_key(self):
         node2 = Delayable(self.env["test.queue.job"]).create_ir_logging(
             "test_delay_graph_direct_exec 2"
         )
-        node2.done(node)
+        node2.on_done(node)
         node2.delay()
         # jobs are executed directly
         logs = self.env["ir.logging"].search(

test_queue_job/tests/test_delayable.py

@@ -57,18 +57,18 @@ def test_delayable_delay_single(self):
         node.delay()
         self.assert_generated_job(node)
 
-    def test_delayable_delay_done(self):
+    def test_delayable_delay_on_done(self):
         node = self.job_node(1)
         node2 = self.job_node(2)
-        node.done(node2).delay()
+        node.on_done(node2).delay()
         self.assert_generated_job(node, node2)
         self.assert_dependencies({node: {}, node2: {node}})
 
     def test_delayable_delay_done_multi(self):
         node = self.job_node(1)
         node2 = self.job_node(2)
         node3 = self.job_node(3)
-        node.done(node2, node3).delay()
+        node.on_done(node2, node3).delay()
         self.assert_generated_job(node, node2, node3)
         self.assert_dependencies({
             node: {}, node2: {node}, node3: {node}
@@ -94,7 +94,7 @@ def test_delayable_delay_job_after_group(self):
         node = self.job_node(1)
         node2 = self.job_node(2)
         node3 = self.job_node(3)
-        DelayableGroup(node, node2).done(node3).delay()
+        DelayableGroup(node, node2).on_done(node3).delay()
         self.assert_generated_job(node, node2, node3)
         self.assert_dependencies({
             node: {}, node2: {}, node3: {node, node2}
@@ -107,7 +107,7 @@ def test_delayable_delay_group_after_group(self):
         node4 = self.job_node(4)
         g1 = DelayableGroup(node, node2)
         g2 = DelayableGroup(node3, node4)
-        g1.done(g2).delay()
+        g1.on_done(g2).delay()
         self.assert_generated_job(node, node2, node3, node4)
         self.assert_dependencies({
             node: {}, node2: {},
@@ -120,7 +120,7 @@ def test_delayable_delay_implicit_group_after_group(self):
         node2 = self.job_node(2)
         node3 = self.job_node(3)
         node4 = self.job_node(4)
-        g1 = DelayableGroup(node, node2).done(node3, node4)
+        g1 = DelayableGroup(node, node2).on_done(node3, node4)
         g1.delay()
         self.assert_generated_job(node, node2, node3, node4)
         self.assert_dependencies({
@@ -138,7 +138,7 @@ def test_delayable_delay_group_after_group_after_group(self):
         g2 = DelayableGroup(node2)
         g3 = DelayableGroup(node3)
         g4 = DelayableGroup(node4)
-        g1.done(g2.done(g3.done(g4))).delay()
+        g1.on_done(g2.on_done(g3.on_done(g4))).delay()
         self.assert_generated_job(node, node2, node3, node4)
         self.assert_dependencies({
             node: {},
@@ -153,8 +153,8 @@ def test_delayable_diamond(self):
         node3 = self.job_node(3)
         node4 = self.job_node(4)
         g1 = DelayableGroup(node2, node3)
-        g1.done(node4)
-        node.done(g1)
+        g1.on_done(node4)
+        node.on_done(g1)
         node.delay()
         self.assert_generated_job(node, node2, node3, node4)
         self.assert_dependencies({
@@ -196,7 +196,7 @@ def test_delayable_chain_after_job(self):
         node3 = self.job_node(3)
         node4 = self.job_node(4)
         c1 = DelayableChain(node2, node3, node4)
-        node.done(c1)
+        node.on_done(c1)
         node.delay()
         self.assert_generated_job(node, node2, node3, node4)
         self.assert_dependencies({
@@ -215,7 +215,7 @@ def test_delayable_chain_after_chain(self):
         node6 = self.job_node(6)
         chain1 = DelayableChain(node, node2, node3)
         chain2 = DelayableChain(node4, node5, node6)
-        chain1.done(chain2)
+        chain1.on_done(chain2)
         chain1.delay()
         self.assert_generated_job(node, node2, node3, node4, node5, node6)
         self.assert_dependencies({
@@ -240,7 +240,7 @@ def test_delayable_group_of_chain(self):
         chain2 = DelayableChain(node3, node4)
         chain3 = DelayableChain(node5, node6)
         chain4 = DelayableChain(node7, node8)
-        g1 = DelayableGroup(chain1, chain2).done(chain3, chain4)
+        g1 = DelayableGroup(chain1, chain2).on_done(chain3, chain4)
         g1.delay()
         self.assert_generated_job(
             node, node2, node3, node4,
@@ -278,6 +278,6 @@ def test_delay_job_already_exists(self):
         node = self.job_node(1)
         node2 = self.job_node(2)
         node2.delay()
-        node.done(node2).delay()
+        node.on_done(node2).delay()
         self.assert_generated_job(node, node2)
         self.assert_dependencies({node: {}, node2: {node}})