Fix false config validation warnings for process selectors (#6542)

Signed-off-by: Ben Sherman <[email protected]>

Author: bentsherman

modules/nextflow/src/main/groovy/nextflow/config/ConfigValidator.groovy

@@ -89,35 +89,35 @@ class ConfigValidator {
         pluginScopes = new SpecNode.Scope('', children)
     }
 
-    void validate(ConfigMap config) {
-        validate(config.toConfigObject())
-    }
+    /**
+     * Validate a config block within the given scope.
+     *
+     * @param config
+     * @param scopes
+     */
+    void validate(Map<String,?> config, List<String> scopes=[]) {
+        for( final entry : config.entrySet() ) {
+            final key = entry.key
+            final value = entry.value
+
+            final names = scopes + [key]
+
+            if( names.size() == 2 && names.first() == 'profiles' )
+                names.clear()
 
-    void validate(ConfigObject config) {
-        final flatConfig = config.flatten()
-        for( String key : flatConfig.keySet() ) {
-            final names = key.tokenize('.').findAll { name -> !isSelector(name) }
-            if( names.first() == 'profiles' ) {
-                if( !names.isEmpty() ) names.remove(0)
-                if( !names.isEmpty() ) names.remove(0)
+            if( value instanceof Map ) {
+                log.debug "validate config block ${names}"
+                if( isSelector(key) )
+                    names.removeLast()
+                log.debug "  is map option ${isMapOption(names)}"
+                if( isMapOption(names) )
+                    continue
+                validate(value, names)
             }
-            final scope = names.first()
-            if( scope == 'env' ) {
-                checkEnv(names.last())
-                continue
+            else {
+                log.debug "validate config option ${names}"
+                validateOption(names)
             }
-            if( scope == 'params' )
-                continue
-            final fqName = names.join('.')
-            if( fqName.startsWith('process.ext.') )
-                continue
-            if( isValid(names) )
-                continue
-            if( isMissingCorePluginScope(names.first()) )
-                continue
-            if( isMapOption(names) )
-                continue
-            log.warn1 "Unrecognized config option '${fqName}'"
         }
     }
 
@@ -130,6 +130,29 @@ class ConfigValidator {
         return name.startsWith('withLabel:') || name.startsWith('withName:')
     }
 
+    /**
+     * Validate a config option given by the list of names.
+     *
+     * For example, the option 'process.resourceLimits' is represented
+     * as ['process', 'resourceLimits'].
+     *
+     * @param names
+     */
+    void validateOption(List<String> names) {
+        final scope = names.first()
+        if( scope == 'env' ) {
+            checkEnv(names.last())
+            return
+        }
+        if( scope == 'params' )
+            return
+        if( isMissingCorePluginScope(scope) )
+            return
+        if( isValid(names) )
+            return
+        log.warn1 "Unrecognized config option '${names.join('.')}'"
+    }
+
     /**
      * Determine whether a config option is defined in the spec.
      *
@@ -161,26 +184,16 @@ class ConfigValidator {
      * Determine whether a config option is a map option or a
      * property thereof.
      *
-     * @param names Config option split into individual names, e.g. 'process.resourceLimits' -> [process, resourceLimits]
+     * @param names
      */
     private boolean isMapOption(List<String> names) {
         return isMapOption0(SpecNode.ROOT, names)
             || isMapOption0(pluginScopes, names)
     }
 
     private static boolean isMapOption0(SpecNode.Scope scope, List<String> names) {
-        SpecNode node = scope
-        for( final name : names ) {
-            if( node instanceof SpecNode.Scope )
-                node = node.children().get(name)
-            else if( node instanceof SpecNode.Placeholder )
-                node = node.scope()
-            else if( node instanceof SpecNode.Option )
-                return node.type() == Map.class
-            else
-                return false
-        }
-        return false
+        final node = scope.getOption(names)
+        return node != null && node.type() == Map.class
     }
 
     /**

modules/nextflow/src/test/groovy/nextflow/config/ConfigValidatorTest.groovy

@@ -29,34 +29,62 @@ class ConfigValidatorTest extends Specification {
     OutputCapture capture = new OutputCapture()
 
     def 'should warn about invalid config options' () {
-        given:
-        def config = new ConfigMap([
+        when:
+        new ConfigValidator().validate([
             wokDir: 'work',
             workDir: 'work',
             process: [
                 cpu: 2,
                 cpus: 2
             ]
         ])
-
-        when:
-        new ConfigValidator().validate(config)
         then:
         capture.toString().contains('Unrecognized config option \'wokDir\'')
         capture.toString().contains('Unrecognized config option \'process.cpu\'')
         !capture.toString().contains('Unrecognized config option \'workDir\'')
         !capture.toString().contains('Unrecognized config option \'process.cpus\'')
     }
 
+    def 'should validate config options in profiles' () {
+        when:
+        new ConfigValidator().validate([
+            profiles: [
+                test: [
+                    workDir: 'work',
+                    process: [
+                        cpus: 2
+                    ]
+                ]
+            ]
+        ])
+        then:
+        !capture.toString().contains('Unrecognized config option')
+
+        when:
+        new ConfigValidator().validate([
+            profiles: [
+                test: [
+                    wokDir2: 'work',
+                    process: [
+                        cpu2: 2
+                    ]
+                ]
+            ]
+        ])
+        then:
+        capture.toString().contains('Unrecognized config option \'wokDir2\'')
+        capture.toString().contains('Unrecognized config option \'process.cpu2\'')
+    }
+
     def 'should warn about invalid env config options' () {
         when:
-        new ConfigValidator().validate(new ConfigMap([
+        new ConfigValidator().validate([
             env: [
                 FOO: '/something',
                 NXF_ANSI_SUMMARY: 'true',
                 NXF_DEBUG: 'true'
             ]
-        ]))
+        ])
 
         then:
         capture.toString().contains('the following environment variable in the config will be ignored: \'NXF_ANSI_SUMMARY\'')
@@ -65,27 +93,27 @@ class ConfigValidatorTest extends Specification {
     }
 
     def 'should ignore process selectors' () {
-        given:
-        def config = new ConfigMap([
+        when:
+        new ConfigValidator().validate([
             process: [
                 'withLabel:foobar': [
                     cpus: 2
                 ],
                 'withName:foobar': [
                     cpus: 2
+                ],
+                "withName:'.*TASK.*'": [
+                    cpus: 2
                 ]
             ]
         ])
-
-        when:
-        new ConfigValidator().validate(config)
         then:
         !capture.toString().contains('Unrecognized config option')
     }
 
     def 'should support map options' () {
-        given:
-        def config = new ConfigMap([
+        when:
+        new ConfigValidator().validate([
             process: [
                 resourceLimits: [
                     cpus: 4,
@@ -94,9 +122,6 @@ class ConfigValidatorTest extends Specification {
                 ]
             ]
         ])
-
-        when:
-        new ConfigValidator().validate(config)
         then:
         !capture.toString().contains('Unrecognized config option')
     }