Merge pull request #739 from arcivanov/issue_737

Multiple fixes for late injection of dependencies

src/integrationtest/python/issue_737_tests.py

@@ -0,0 +1,75 @@
+#   -*- coding: utf-8 -*-
+#
+#   This file is part of PyBuilder
+#
+#   Copyright 2011-2020 PyBuilder Team
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+
+import unittest
+
+from itest_support import IntegrationTestSupport
+
+
+class Test(IntegrationTestSupport):
+    def test(self):
+        self.write_build_file("""
+from pybuilder.core import use_plugin, init
+import sys
+from os.path import join as jp, normcase as nc, dirname
+
+build_sources = nc(jp(dirname(__file__), "src/main/python"))
+if build_sources not in sys.path:
+    sys.path.insert(0, build_sources)
+
+use_plugin("issue_737_plugin_2")
+use_plugin("issue_737_plugin_1")
+
+name = "pybuilder-defaults-plugin"
+version = "1.1.1"
+summary = "PyBuilder plugin to provide common configuration for python projects"
+default_task = ["task2"]
+
+@init
+def init (project):
+    pass
+""")
+        self.create_directory("src/main/python")
+        self.write_file("src/main/python/issue_737_plugin_1.py", r"""
+from pybuilder.core import init, task, depends
+
+@task
+def task1():
+    pass
+
+@task
+@depends("task1")
+def task2():
+    pass
+""")
+        self.write_file("src/main/python/issue_737_plugin_2.py", r"""
+from pybuilder.core import init, use_plugin, task, depends, dependents, optional
+
+@task
+@depends("task1")
+@dependents(optional("task2"))
+def taskX():
+    pass
+""")
+        reactor = self.prepare_reactor()
+        reactor.build()
+
+
+if __name__ == "__main__":
+    unittest.main()

src/main/python/pybuilder/execution.py

@@ -122,7 +122,6 @@ def __repr__(self):
 class TaskDependency(object):
     def __init__(self, mixed, optional=False):
         self._name = as_task_name(mixed)
-        self._task = mixed if hasattr(mixed, "name") else None
         self._optional = optional
 
     def __repr__(self):
@@ -136,14 +135,13 @@ def __eq__(self, other):
     def name(self):
         return self._name
 
-    @property
-    def task(self):
-        return self._task
-
     @property
     def optional(self):
         return self._optional
 
+    def required(self):
+        self._optional = False
+
 
 class Task(object):
     def __init__(self, name, callable_, dependencies=None, description=""):
@@ -282,15 +280,17 @@ def register_task(self, *tasks):
 
     def register_late_task_dependencies(self, dependencies):
         for name in dependencies:
-            self.logger.debug("Registering late dependency of task '%s' on %s", name, dependencies[name])
+            dependency_tasks = dependencies[name]
+            self.logger.debug("Registering late dependency of task '%s' on %s", name, dependency_tasks)
             if name not in self._dependencies_pending_tasks:
                 self._dependencies_pending_tasks[name] = []
-            self._dependencies_pending_tasks[name].extend(dependencies[name])
+            self._dependencies_pending_tasks[name].extend(dependency_tasks)
 
         for name in list(self._dependencies_pending_tasks.keys()):
             if self.has_task(name):
-                self.logger.debug("Resolved late dependency of task '%s' on %s", name, dependencies[name])
-                self.get_task(name).dependencies.extend(self._dependencies_pending_tasks[name])
+                dependency_tasks = self._dependencies_pending_tasks[name]
+                self.logger.debug("Resolved late dependency of task '%s' on %s", name, dependency_tasks)
+                self.get_task(name).dependencies.extend(dependency_tasks)
                 del self._dependencies_pending_tasks[name]
 
     def execute_initializers(self, environments=None, **kwargs):
@@ -418,7 +418,7 @@ def _collect_transitive_tasks(self, task, visited=None):
         visited.add(task)
         dependencies = [dependency for dependency in self._task_dependencies[task.name]]
         for dependency in dependencies:
-            self._collect_transitive_tasks(dependency.task, visited)
+            self._collect_transitive_tasks(self.get_task(dependency.name), visited)
         return visited
 
     def collect_all_transitive_tasks(self, task_names):
@@ -519,7 +519,7 @@ def resolve_dependencies(self, exclude_optional_tasks=None, exclude_tasks=None,
                     if existing_dependency.name == d.name:
                         if existing_dependency.optional != d.optional:
                             if existing_dependency.optional:
-                                task_dependencies[index] = TaskDependency(existing_dependency.name)
+                                existing_dependency.required()
                                 self.logger.debug("Converting optional dependency '%s' of task '%s' into required",
                                                   existing_dependency, task.name)
                             else:

src/unittest/python/execution_tests.py

@@ -594,10 +594,13 @@ def test_verify_late_dependency(self):
         one = Mock(name="one", dependencies=[])
         two = Mock(name="two", dependencies=[TaskDependency("one")])
         three = Mock(name="three", dependencies=[TaskDependency("one")])
+        four = Mock(name="four", dependencies=[])
 
         self.execution_manager.register_task(one, two)
         self.execution_manager.register_task(three)
-        self.execution_manager.register_late_task_dependencies({"two": [TaskDependency("three")]})
+        self.execution_manager.register_late_task_dependencies({"two": [TaskDependency("three")],
+                                                                "four": [TaskDependency("two")]})
+        self.execution_manager.register_task(four)
         self.execution_manager.resolve_dependencies()
 
         self.assertEqual([], self.execution_manager._task_dependencies.get("one"))
@@ -630,8 +633,7 @@ def test_verify_error_unresolved_late_dependency(self):
 
         self.execution_manager.register_task(one, two)
         self.execution_manager.register_task(three)
-        self.execution_manager.register_late_task_dependencies(
-            {"four": [TaskDependency("three")]})
+        self.execution_manager.register_late_task_dependencies({"four": [TaskDependency("three")]})
         self.assertRaises(NoSuchTaskException, self.execution_manager.resolve_dependencies)