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,20 @@ def prepare(self, inputEnv, sandboxEnabled, inputStates, inputSandbox=None,
         depDiffSandbox = diffSandbox
         depDiffTools = diffTools.copy()
         thisDeps = {}
+        depVars = set()
+        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 })
 
+            depsEnv = env.derive()
+            depsEnv.touchReset()
+            dep.recipe = depsEnv.substitute(dep.recipe, "dependency::"+dep.recipe)
+            resolvedDeps.append(dep.recipe)
+            depVars = set([e for e in depsEnv.touchedKeys()])
+
             if dep.condition and not all(env.evaluate(cond, "dependency "+dep.recipe)
                                                       for cond in dep.condition): continue
 
@@ -2449,10 +2449,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.
@@ -2544,7 +2558,7 @@ def prepare(self, inputEnv, sandboxEnabled, inputStates, inputSandbox=None,
 
         # optional checkout step
         if self.__checkout != (None, None, None) or self.__checkoutSCMs or self.__checkoutAsserts:
-            checkoutDigestEnv = env.prune(self.__checkoutVars)
+            checkoutDigestEnv = env.prune(self.__checkoutVars | depVars)
             checkoutEnv = ( env.prune(self.__checkoutVars | self.__checkoutVarsWeak)
                 if self.__checkoutVarsWeak else checkoutDigestEnv )
             checkoutUpdateIf = [
@@ -2570,7 +2584,7 @@ def prepare(self, inputEnv, sandboxEnabled, inputStates, inputSandbox=None,
 
         # optional build step
         if self.__build != (None, None, None):
-            buildDigestEnv = env.prune(self.__buildVars)
+            buildDigestEnv = env.prune(self.__buildVars | depVars)
             buildEnv = ( env.prune(self.__buildVars | self.__buildVarsWeak)
                 if self.__buildVarsWeak else buildDigestEnv )
             buildCoreStep = p.createCoreBuildStep(self.__build, buildDigestEnv, buildEnv,
@@ -2579,7 +2593,7 @@ def prepare(self, inputEnv, sandboxEnabled, inputStates, inputSandbox=None,
             buildCoreStep = p.createInvalidCoreBuildStep([CoreRef(srcCoreStep)] + results)
 
         # mandatory package step
-        packageDigestEnv = env.prune(self.__packageVars)
+        packageDigestEnv = env.prune(self.__packageVars | depVars)
         packageEnv = ( env.prune(self.__packageVars | self.__packageVarsWeak)
             if self.__packageVarsWeak else packageDigestEnv )
         packageCoreStep = p.createCorePackageStep(self.__package, packageDigestEnv, packageEnv,

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: "true"
+            """)
+        self.writeRecipe("c-foo", """\
+            buildScript: "true"
+            packageScript: "true"
+            """)
+        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", """\