fixup! fixup! 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")
@@ -2357,6 +2347,7 @@ def prepare(self, inputEnv, sandboxEnabled, inputStates, inputSandbox=None,
         depDiffTools = diffTools.copy()
         thisDeps = {}
         depVars = set()
+        resolvedDeps = []
 
         for d in self.__deps:
             dep = copy.deepcopy(d)
@@ -2366,6 +2357,7 @@ def prepare(self, inputEnv, sandboxEnabled, inputStates, inputSandbox=None,
             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)
@@ -2463,13 +2455,18 @@ def prepare(self, inputEnv, sandboxEnabled, inputStates, inputSandbox=None,
                         for d in depCoreStep.providedDeps])
             maybeProvideDeps[dep.recipe] = l
 
-        __provideDeps = [ env.substitute(p, "providedDep::"+p)
-                for p in self.__provideDeps]
+        # 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, refs in maybeProvideDeps.items():
-            if recipe in __provideDeps:
-                provideDeps.append(refs[0])
-                provideDeps.extend(refs[1])
+        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

@@ -272,18 +272,19 @@ def testVariableDeps(self):
             """)
 
         self.writeRecipe("a", """\
-            depends: [ "$A" ]
+            depends: [ "$A-foo" ]
             buildScript: "true"
             packageScript: "true"
+            provideDeps: [ "$A-f*" ]
             provideVars:
                 D: "e"
             """)
 
-        self.writeRecipe("b", """\
+        self.writeRecipe("b-foo", """\
             buildScript: "true"
             packageScript: "true"
             """)
-        self.writeRecipe("c", """\
+        self.writeRecipe("c-foo", """\
             buildScript: "true"
             packageScript: "true"
             """)
@@ -304,12 +305,15 @@ def testVariableDeps(self):
         recipes.parse()
         packages = recipes.generatePackages(lambda x,y: "unused")
 
-        p = packages.walkPackagePath("root/a/b")
-        self.assertEqual(p.getName(), "b")
-        p = packages.walkPackagePath("root2/a/c")
-        self.assertEqual(p.getName(), "c")
+        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"""