Modules do have a config file: https://nf-co.re/docs/guidelines/components/modules#optional-command-arguments this generally lives in

config/modules.config

eg https://github.com/nf-core/pixelator/blob/2.3.0/conf/modules.config

I'd like to have the optional arguments present in a file somewhere, so people will know what to use, including when incorporating into pipelines.

This is something I'm interested in as well but I have a feeling it falls outside the scope of the nf-core modules. Take the

samtools_depth

module https://github.com/nf-core/modules/blob/master/modules/nf-core/samtools/depth/main.nf The actual script part is tiny:

samtools \\
        depth \\
        --threads ${task.cpus-1} \\
        $args \\
        $positions \\
        -o ${prefix}.tsv \\
        $bam

Even though the number of possible arguments are a lot. I think it's expected that the user knows how to use the tool and would seek out the documentation or seek out its usage in other nf-core pipelines.

So write the module to allow the tool to run, make sure user can find documentation somewhere and leave it up to them.

I mean tests of the specific module, not tests of a pipeline

for instance the bam_ngscheckmate subworkflow has a nextflow.config that is required to ensure that bcftools makes the right files for ngscheckmate,

image.png

If you think the wording can be improved you are welcome to submit a PR to the website 🙂

How about this:

## Optional command arguments

All _non-mandatory_ command-line tool _non-file_ arguments MUST supported in the module via the `$task.ext.args` variable.

The `$args` variable MUST be placed in the module's tool command to allow optional and/or dynamic variables to be specified by a user or a developer.
The contents of this variable is specified by a pipeline developer or user in with the `ext.args` process variable in a `modules.config` or other Nextflow config file using a closure.
The `$ext.args` variable can also be used in module tests to increase the test coverage of a tool's functionality through a companion `nextflow.config` alongside the test files themselves.

```groovy {2} title="<module>.nf"
script:
def args = task.ext.args ?: ''
def prefix = task.ext.prefix ?: "${meta.id}"
"""
fastqc \\
    $args \\
      <...>
"""

groovy {3-6} title="modules.config"
  process {
    withName: <module> {
        ext.args = { [                                                        // Assign a closure which returns a string
            '--quiet',
            params.fastqc_kmer_size ? "-k ${params.fastqc_kmer_size}" : ''    // Parameter-dependent values can be provided in this way
        ].join(' ') }                                                         // Join converts the list to a string.
        ext.prefix = { "${meta.id}" }                                         // A closure can be used to access variables defined in the script
    }
  }

:::info{title="Rationale" collapse} Passing arguments via ext.args splits how information is passed to a module, making it harder to understand where module inputs are defined. Using

ext.args

provides more flexibility to users. As

ext.args

is derived from the configuration (e.g.,,

modules.config

), advanced users can overwrite the default

ext.args

and supply their own arguments to modify the behaviour of a module. This can increase the capabilities of a pipeline beyond what the original developers intended. Initially, these were passed via the main workflow script using custom functions (e.g.,

addParams

) and other additional nf-core custom methods, but this syntax overhead and other limitations were more difficult for pipeline developers to use and understand. Using the 'native'

ext

functionality provided by Nextflow was easier to understand, maintain, and use. Sample-specific parameters can still be provided to an instance of a process by storing these in

meta

, and providing these to the

ext.args

definition in

modules.config

. A closure is used to make Nextflow evaluate the code in the string:

groovy
ext.args = { "--id ${meta.id}" }

::: ```

?