schema.config

import org.yaml.snakeyaml.Yaml
includeConfig "./custom_schema_types.config"
/**
* This schema namespace is used to valide the params defined in config file(s) using a schema
* YAML file. This config script should be included and called through `schema.validate()` at the
* very bottom.
*/
schema {
    type_map = [
        'Integer'  : Integer,
        'String'   : [String, GString],
        'Number'   : Number,
        'List'     : List,
        'Bool'     : Boolean,
        'Namespace': Map,
        'Path'     : [String, GString]
    ]
    required_properties = ['type']
    path_types = ['Path']
    custom_types = [:]

    single_choice_types = [
        'String',
        'Path',
        'Number',
        'Integer'
    ]

    /**
    * Load the schema file.
    */
    load_schema = { String file_path ->
        def schema_file = new File(file_path)
        Yaml parser = new Yaml()
        def yaml = parser.load(schema_file.text)
        return yaml
    }

    /**
    * Check that given directory either exists and is writeable or is createable.
    * @throws IOException when directory cannot be written to or created.
    */
    check_write_permission = { File dir ->
        if (dir.exists()) {
            if (!dir.canWrite()) {
                throw new IOException("   ### ERROR ###   The directory ${dir} is not writeable. Please verify and try again.")
            }
        } else {
            while (!dir.exists()) {
                dir = dir.getParentFile()
            }
            if (!dir.canWrite()) {
                throw new IOException("   ### ERROR ###   The directory ${dir} cannot be created. The closest existing parent directory ${dir.toString()} is not writable. Please verify permissions or change the input parameter.")
            }
        }
    }

    /**
    * Check type for paths (writeable or readable). Accepts path as String for validation.
    * @throws FileNotFoundException when file does not exist.
    * @throws IOException when file cannot be read.
    */
    check_path = { String p, String mode ->
        def File file = new File(p)
        file = file.getAbsoluteFile()
        if (mode == 'w') {
            schema.check_write_permission(file)
            return
        }
        if (!(file.exists())) {
            throw new FileNotFoundException("${file} does not exist.")
        }
        if (!(file.canRead())) {
            throw new IOException("${file} is not readable.")
        }
    }

    /**
    * Set default properties from the schema.
    */
    set_default_properties = { Map properties ->
        if (!properties.containsKey('help')) {
            properties['help'] = ''
        }
        if (!properties.containsKey('required')) {
            properties['required'] = false
        }
        if (properties['type'] in schema.path_types && !properties.containsKey('mode')) {
            properties['mode'] = 'r'
        }
        if (properties['type'] in schema.type_map['String'] && !properties.containsKey('allow_empty')) {
            properties['allow_empty'] = false
        }
        if (properties['type'] in schema.type_map['List'] && !properties.containsKey('allow_empty')) {
            properties['allow_empty'] = false
        }
    }

    /**
    * Check whether the required properties are defined for the corresponding parameter from the
    * schema yaml file.
    *
    * @throws IllegalArgumentException when config file is missing required properties.
    */
    check_required_properties = { String name, Map properties ->
        schema.required_properties.each { property ->
            if (!properties.containsKey(property)) {
                throw new IllegalArgumentException("Config file invalid. Parameter ${name} is missing property ${property}.")
            }
        }
    }

    /**
    * Check whether the required parameter is set from config file(s).
    * @throws IllegalArgumentException when config file is missing required properties.
    */
    check_required = { Map options, String name, Map properties ->
        if (properties['required'] && !options.containsKey(name)) {
            throw new IllegalArgumentException("Config file invalid. Required parameter ${name} is missing.")
        }
    }

    /**
    * Check whether the parameter is set in the correct type, e.g. string, integer, etc.
    * @throws IllegalArgumentException when config file is missing required properties.
    */
    check_type = { Map options, String name, String type ->
        if (! options.containsKey(name)) {
            return false
        }
        if (schema.type_map.containsKey(type)) {
            return schema.primitive_check_type(options, name, type)
        } else if (! schema.custom_types.containsKey(type)) {
            throw new IllegalArgumentException("Invalid parameter type ${type} found from schema.")
        }
        return true
    }

    /**
    * Check type of values
    * @throws IllegalStateException when parameters are not the required type.
    */
    primitive_check_type = { Map options, String name, String type ->
        if (!(schema.type_map[type].any{ options[name] in it })) {
            throw new IllegalStateException("Invalid parameter type for parameter ${name}. Requires ${schema.type_map[type]} but received ${options[name].getClass()}.")
        }
        return true
    }

    /**
    * Check if string/list is empty if necessary
    * @throws IllegalStateException when required non-empty parameters are empty.
    */
    check_non_empty = { Map options, String name, Boolean allow_empty ->
        if (allow_empty) {
            return
        }
        if (options[name].isEmpty()) {
            throw new Exception("Parameter ${name} of type String or List is empty. Please enter a value.")
        }
    }

    /**
    * Check whether the parameter is set within the valid choices.
    * @throws IllegalStateException when invalid choice is used for parameter.
    */
    check_choices_singular = { Map options, String name, List choices ->
        if (!(options[name] in choices)) {
            throw new Exception("Invalid parameter ${name}. Valid values: ${choices}.")
        }
    }

    /**
    * Check whether list contains only valid choices
    * @throws IllegalStateException when invalid choice is used for parameter in a list.
    */
    check_choices_list = { Map options, String name, List choices ->
        for (elem in options[name]) {
            if (!(elem in choices)) {
                throw new Exception("Invalid parameter ${name}. Valid values: ${choices}.")
            }
        }
    }

    /**
    * Check default for given property
    */
    check_default = { Map options, String name, Map properties ->
        if (properties.containsKey('default')) {
            options[name] = properties.default
        }
    }

    /**
    * For a given parameter, check whether the value is set properly from config file(s).
    */
    validate_parameter = { Map options, String name, Map properties ->
        // type is required
        schema.check_required_properties(name, properties)
        schema.set_default_properties(properties)
        if (schema.check_type(options, name, properties.type)) {
            if (properties.type == 'Namespace' && properties.containsKey('elements')) {
                properties.elements.each { key, val ->
                    schema.validate_parameter(options[name], key, val)
                }
            } else if (properties.type == 'List') {
                schema.check_non_empty(options, name, properties.allow_empty)
                if (properties.containsKey('choices')) {
                    schema.check_choices_list(options, name, properties.choices)
                }
            } else if (properties.type == 'String') {
                schema.check_non_empty(options, name, properties.allow_empty)
            } else if (properties.type in schema.path_types) {
                schema.check_path(options[name], properties.mode)
            } else if (schema.custom_types.containsKey(properties.type)) {
                schema.custom_types[properties.type](options, name, properties)
            }

            if (properties.type in schema.single_choice_types && properties.containsKey('choices')) {
                schema.check_choices_singular(options, name, properties.choices)
            }
        } else {
            schema.check_default(options, name, properties)
            schema.check_required(options, name, properties)
        }
    }

    /**
    * Load custom types and validation methods.
    * @throws IllegalStateException when invalid choice is used for parameter.
    * @throws FileNotFoundException when custom_schema_types.config path is not valid.
    */
    load_custom_types = { String custom_types_path=null, Boolean purge_existing_custom_types=false ->
        if (custom_types_path != null) {
            includeConfig "${custom_types_path}"
            if (! custom_schema_types.containsKey('types')) {
                throw new IllegalStateException("Failed to load custom types. Custom config must define namespace 'custom_schema_types' containing a Map 'types' defining the custom types as key and the corresponding function for validation as value.")
            }
            if(purge_existing_custom_types == true){
                schema.custom_types = custom_schema_types.types
            } else {
                if(schema.custom_types.isEmpty()){
                    schema.custom_types = custom_schema_types.types
                } else {
                    schema.custom_types = schema.custom_types + custom_schema_types.types
                }
            }
        } else {
            throw new FileNotFoundException("Failed to load custom types. Custom schema type config is not found.")
        }
    }

    /**
    * Main validation to call, to validate the params from config file(s) against the schema.
    */
    validate = { String file_path="${projectDir}/config/schema.yaml" ->
        def params_schema = schema.load_schema(file_path)
        params_schema.each { key, val ->
            try {
                schema.validate_parameter(params, key, val)
            } catch (Exception ex) {
                System.out.println "Failed to validate parameter key: ${val}"
                throw ex
            }
        }
    }

    /**
    * Fine-grained validation entrypoint; to be used for validating specific namespaces with certain parameters excluded
    * schema_to_validate: path to schema YAML to be used for validation
    * params_to_validate: Map of parameters to validate against schema
    * keys_to_exclude: params to skip during validation
    * @throws IllegalArgumentException when invalid format of schema is provided
    */
    validate_specific = { Object schema_to_validate, Map params_to_validate, List keys_to_exclude=[] ->
        def params_schema;
        if (custom_schema_types.is_string(schema_to_validate)) {
            params_schema = schema.load_schema(schema_to_validate)
        } else if (schema_to_validate in Map) {
            params_schema = schema_to_validate
        } else {
            throw new IllegalArgumentException("The given schema must be a path to the schema YAML or a Map, received `${schema_to_validate.getClass()}` instead.")
        }

        params_schema.removeAll{ key, val -> keys_to_exclude.contains(key) }
        params_schema.each { key, val ->
            schema.validate_parameter(params_to_validate, key, val)
        }
    }
}