input: support for variable depends

Author: rhubert

pym/bob/input.py

@@ -2220,16 +2220,6 @@ def coDet(r):
         if self.__jobServer is None:
             self.__jobServer = False
 
-        # check provided dependencies
-        availDeps = [ d.recipe for d in self.__deps ]
-        providedDeps = set()
-        for pattern in self.__provideDeps:
-            l = set(d for d in availDeps if fnmatch.fnmatchcase(d, pattern))
-            if not l:
-                raise ParseError("Unknown dependency '{}' in provideDeps".format(pattern))
-            providedDeps |= l
-        self.__provideDeps = providedDeps
-
         # Evaluate root property
         if isinstance(self.__root, str) or isinstance(self.__root, IfExpression):
             self.__root = rootEnv.evaluate(self.__root, "root")
@@ -2346,6 +2336,7 @@ def prepare(self, inputEnv, sandboxEnabled, inputStates, inputSandbox=None,
         directPackages = []
         indirectPackages = []
         provideDeps = UniquePackageList(stack, self.__raiseIncompatibleProvided)
+        maybeProvideDeps = {}
         checkoutDeps = []
         results = []
         depEnv = env.derive()
@@ -2355,11 +2346,16 @@ def prepare(self, inputEnv, sandboxEnabled, inputStates, inputSandbox=None,
         depDiffSandbox = diffSandbox
         depDiffTools = diffTools.copy()
         thisDeps = {}
+        resolvedDeps = []
 
-        for dep in self.__deps:
+        for d in self.__deps:
+            dep = copy.deepcopy(d)
             env.setFunArgs({ "recipe" : self, "sandbox" : bool(sandbox) and sandboxEnabled,
                 "__tools" : tools })
 
+            dep.recipe = env.substitute(dep.recipe, "dependency::"+dep.recipe)
+            resolvedDeps.append(dep.recipe)
+
             if dep.condition and not all(env.evaluate(cond, "dependency "+dep.recipe)
                                                       for cond in dep.condition): continue
 
@@ -2449,10 +2445,24 @@ def prepare(self, inputEnv, sandboxEnabled, inputStates, inputSandbox=None,
                 if sandboxEnabled:
                     env.update(sandbox.environment)
                     if dep.provideGlobal: depEnv.update(sandbox.environment)
-            if dep.recipe in self.__provideDeps:
-                provideDeps.append(depRef)
-                provideDeps.extend(CoreRef(d, [p.getName()], origDepDiffTools, origDepDiffSandbox)
-                    for d in depCoreStep.providedDeps)
+
+            l = [depRef]
+            l.append([CoreRef(d, [p.getName()], origDepDiffTools, origDepDiffSandbox)
+                        for d in depCoreStep.providedDeps])
+            maybeProvideDeps[dep.recipe] = l
+
+        # check provided dependencies
+        providedDeps = set()
+        for pattern in self.__provideDeps:
+            pattern = env.substitute(pattern, "providedDep::"+pattern)
+            l = set(d for d in resolvedDeps if fnmatch.fnmatchcase(d, pattern))
+            if not l:
+                raise ParseError("Unknown dependency '{}' in provideDeps".format(pattern))
+            providedDeps |= l
+
+        for recipe in providedDeps:
+            provideDeps.append(maybeProvideDeps[recipe][0])
+            provideDeps.extend(maybeProvideDeps[recipe][1])
 
         # Filter indirect packages and add to result list if necessary. Most
         # likely there are many duplicates that are dropped.

test/unit/test_input_recipeset.py

@@ -251,6 +251,70 @@ def testInvalidMinVerStr(self):
 
 
 class TestDependencies(RecipesTmp, TestCase):
+    def testVariableDeps(self):
+        """Test resolve of dependecies by environment substitution"""
+        self.writeRecipe("root", """\
+            root: True
+            depends: [a]
+            environment:
+                A : "b"
+                D : "c"
+            buildScript: "true"
+            packageScript: "true"
+            """)
+        self.writeRecipe("root2", """\
+            root: True
+            depends: [a, d]
+            environment:
+                A : "c"
+            buildScript: "true"
+            packageScript: "true"
+            """)
+
+        self.writeRecipe("a", """\
+            depends: [ "$A-foo" ]
+            buildScript: "true"
+            packageScript: "true"
+            provideDeps: [ "$A-f*" ]
+            provideVars:
+                D: "e"
+            """)
+
+        self.writeRecipe("b-foo", """\
+            buildScript: "true"
+            packageScript: "echo 'b'"
+            """)
+        self.writeRecipe("c-foo", """\
+            buildScript: "true"
+            packageScript: "echo 'c'"
+            """)
+        self.writeRecipe("d", """\
+            depends:
+             - name: a
+               use: [environment, deps]
+             - "$D"
+            buildScript: "true"
+            packageScript: "true"
+            """)
+        self.writeRecipe("e", """\
+            buildScript: "true"
+            packageScript: "true"
+            """)
+
+        recipes = RecipeSet()
+        recipes.parse()
+        packages = recipes.generatePackages(lambda x,y: "unused")
+
+        p = packages.walkPackagePath("root/a/b-foo")
+        self.assertEqual(p.getName(), "b-foo")
+        p = packages.walkPackagePath("root2/a/c-foo")
+        self.assertEqual(p.getName(), "c-foo")
+        p = packages.walkPackagePath("root2/d/e")
+        self.assertEqual(p.getName(), "e")
+        #access via providedDeps
+        p = packages.walkPackagePath("root/b-foo")
+        self.assertEqual(p.getName(), "b-foo")
+
     def testDuplicateRemoval(self):
         """Test that provided dependencies do not replace real dependencies"""
         self.writeRecipe("root", """\