Remove def software lines and emit versions channel as plural (#780)

* Remove def software line

* Replace version with versions in emit statement

* Fix default software names

modules/abacas/main.nf

@@ -24,10 +24,9 @@ process ABACAS {
 
     output:
     tuple val(meta), path('*.abacas*'), emit: results
-    path "versions.yml"               , emit: version
+    path "versions.yml"               , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     abacas.pl \\

modules/adapterremoval/main.nf

@@ -23,10 +23,9 @@ process ADAPTERREMOVAL {
     output:
     tuple val(meta), path('*.fastq.gz'), emit: reads
     tuple val(meta), path('*.log')     , emit: log
-    path "versions.yml"                , emit: version
+    path "versions.yml"                , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
 
     if (meta.single_end) {

modules/agrvate/main.nf

@@ -24,10 +24,9 @@ process AGRVATE {
     output:
     tuple val(meta), path("${fasta.baseName}-results/${fasta.baseName}-summary.tab"), emit: summary
     path "${fasta.baseName}-results"                                                , emit: results_dir
-    path "versions.yml"                                                             , emit: version
+    path "versions.yml"                                                             , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     agrvate \\

modules/allelecounter/main.nf

@@ -24,10 +24,9 @@ process ALLELECOUNTER {
 
     output:
     tuple val(meta), path("*.alleleCount"), emit: allelecount
-    path "versions.yml"                   , emit: version
+    path "versions.yml"                   , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     alleleCounter \\

modules/amps/main.nf

@@ -27,7 +27,7 @@ process AMPS {
     path "results/heatmap_overview_Wevid.pdf"  , emit: summary_pdf
     path "results/heatmap_overview_Wevid.tsv"  , emit: tsv
     path "results/pdf_candidate_profiles/"     , emit: candidate_pdfs
-    path "versions.yml"                        , emit: version
+    path "versions.yml"                        , emit: versions
 
     script:
     """
@@ -41,7 +41,7 @@ process AMPS {
 
     cat <<-END_VERSIONS > versions.yml
     ${getProcessName(task.process)}:
-        amps: \$(echo \$(hops --version 2>&1) | sed 's/HOPS version//')
+        ${getSoftwareName(task.process)}: \$(echo \$(hops --version 2>&1) | sed 's/HOPS version//')
     END_VERSIONS
     """
 }

modules/arriba/main.nf

@@ -26,10 +26,9 @@ process ARRIBA {
     output:
     tuple val(meta), path("*.fusions.tsv")          , emit: fusions
     tuple val(meta), path("*.fusions.discarded.tsv"), emit: fusions_fail
-    path "versions.yml"                             , emit: version
+    path "versions.yml"                             , emit: versions
 
     script:
-    def software  = getSoftwareName(task.process)
     def prefix    = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     def blacklist = (options.args.contains('-b')) ? '' : '-f blacklist'
     """

modules/artic/guppyplex/main.nf

@@ -23,10 +23,9 @@ process ARTIC_GUPPYPLEX {
 
     output:
     tuple val(meta), path("*.fastq.gz"), emit: fastq
-    path  "versions.yml"               , emit: version
+    path  "versions.yml"               , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     artic \\

modules/artic/minion/main.nf

@@ -40,10 +40,9 @@ process ARTIC_MINION {
     tuple val(meta), path("${prefix}.pass.vcf.gz")                    , emit: vcf
     tuple val(meta), path("${prefix}.pass.vcf.gz.tbi")                , emit: tbi
     tuple val(meta), path("*.json"), optional:true                    , emit: json
-    path  "versions.yml"                                              , emit: version
+    path  "versions.yml"                                              , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     prefix       = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     def version  = scheme_version.toString().toLowerCase().replaceAll('v','')
     def fast5    = params.fast5_dir          ? "--fast5-directory $fast5_dir"             : ""

modules/bamaligncleaner/main.nf

@@ -23,10 +23,9 @@ process BAMALIGNCLEANER {
 
     output:
     tuple val(meta), path("*.bam"), emit: bam
-    path "versions.yml"           , emit: version
+    path "versions.yml"           , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
 
     """

modules/bandage/image/main.nf

@@ -24,10 +24,9 @@ process BANDAGE_IMAGE {
     output:
     tuple val(meta), path('*.png'), emit: png
     tuple val(meta), path('*.svg'), emit: svg
-    path  "versions.yml"          , emit: version
+    path  "versions.yml"          , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     Bandage image $gfa ${prefix}.png $options.args

modules/bbmap/align/main.nf

@@ -24,10 +24,9 @@ process BBMAP_ALIGN {
 
     output:
     tuple val(meta), path("*.bam"), emit: bam
-    path "versions.yml"           , emit: version
+    path "versions.yml"           , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
 
     input = meta.single_end ? "in=${fastq}" : "in=${fastq[0]} in2=${fastq[1]}"

modules/bbmap/bbduk/main.nf

@@ -24,10 +24,9 @@ process BBMAP_BBDUK {
     output:
     tuple val(meta), path('*.fastq.gz'), emit: reads
     tuple val(meta), path('*.log')     , emit: log
-    path "versions.yml"                , emit: version
+    path "versions.yml"                , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     def raw      = meta.single_end ? "in=${reads[0]}" : "in1=${reads[0]} in2=${reads[1]}"
     def trimmed  = meta.single_end ? "out=${prefix}.fastq.gz" : "out1=${prefix}_1.fastq.gz out2=${prefix}_2.fastq.gz"

modules/bbmap/bbsplit/main.nf

@@ -30,10 +30,9 @@ process BBMAP_BBSPLIT {
     tuple val(meta), path('*primary*fastq.gz'), optional:true, emit: primary_fastq
     tuple val(meta), path('*fastq.gz')        , optional:true, emit: all_fastq
     tuple val(meta), path('*txt')             , optional:true, emit: stats
-    path "versions.yml"                       , emit: version
+    path "versions.yml"                       , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
 
     def avail_mem = 3

modules/bbmap/index/main.nf

@@ -23,10 +23,9 @@ process BBMAP_INDEX {
 
     output:
     path 'ref'                    , emit: index
-    path "versions.yml"           , emit: version
+    path "versions.yml"           , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     """
     bbmap.sh \\
         ref=${fasta} \\

modules/bcftools/concat/main.nf

@@ -23,10 +23,9 @@ process BCFTOOLS_CONCAT {
 
     output:
     tuple val(meta), path("*.gz"), emit: vcf
-    path  "versions.yml"         , emit: version
+    path  "versions.yml"         , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     prefix       = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     bcftools concat \\

modules/bcftools/consensus/main.nf

@@ -23,10 +23,9 @@ process BCFTOOLS_CONSENSUS {
 
     output:
     tuple val(meta), path('*.fa'), emit: fasta
-    path  "versions.yml"         , emit: version
+    path  "versions.yml"         , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     cat $fasta | bcftools consensus $vcf $options.args > ${prefix}.fa

modules/bcftools/filter/main.nf

@@ -23,10 +23,9 @@ process BCFTOOLS_FILTER {
 
     output:
     tuple val(meta), path("*.gz"), emit: vcf
-    path  "versions.yml"         , emit: version
+    path  "versions.yml"         , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     bcftools filter \\

modules/bcftools/isec/main.nf

@@ -23,10 +23,9 @@ process BCFTOOLS_ISEC {
 
     output:
     tuple val(meta), path("${prefix}"), emit: results
-    path  "versions.yml"              , emit: version
+    path  "versions.yml"              , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     prefix       = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     bcftools isec  \\

modules/bcftools/merge/main.nf

@@ -23,10 +23,9 @@ process BCFTOOLS_MERGE {
 
     output:
     tuple val(meta), path("*.gz"), emit: vcf
-    path  "versions.yml"         , emit: version
+    path  "versions.yml"         , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     prefix       = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     bcftools merge -Oz \\

modules/bcftools/mpileup/main.nf

@@ -26,10 +26,9 @@ process BCFTOOLS_MPILEUP {
     tuple val(meta), path("*.gz")      , emit: vcf
     tuple val(meta), path("*.tbi")     , emit: tbi
     tuple val(meta), path("*stats.txt"), emit: stats
-    path  "versions.yml"               , emit: version
+    path  "versions.yml"               , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     echo "${meta.id}" > sample_name.list

modules/bcftools/norm/main.nf

@@ -24,10 +24,9 @@ process BCFTOOLS_NORM {
 
     output:
     tuple val(meta), path("*.gz") , emit: vcf
-    path "versions.yml"           , emit: version
+    path "versions.yml"           , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     bcftools norm \\

modules/bcftools/query/main.nf

@@ -26,10 +26,9 @@ process BCFTOOLS_QUERY {
 
     output:
     tuple val(meta), path("*.gz") , emit: vcf
-    path "versions.yml"           , emit: version
+    path "versions.yml"           , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     def regions_file  = regions ? "--regions-file ${regions}" : ""
     def targets_file = targets ? "--targets-file ${targets}" : ""

modules/bcftools/reheader/main.nf

@@ -25,10 +25,9 @@ process BCFTOOLS_REHEADER {
 
     output:
     tuple val(meta), path("*.vcf.gz"), emit: vcf
-    path "versions.yml"              , emit: version
+    path "versions.yml"              , emit: versions
 
     script:
-    def software         = getSoftwareName(task.process)
     def prefix           = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     def update_sequences = fai ? "-f $fai" : ""
     def new_header       = header ? "-h $header" : ""

modules/bcftools/stats/main.nf

@@ -23,10 +23,9 @@ process BCFTOOLS_STATS {
 
     output:
     tuple val(meta), path("*stats.txt"), emit: stats
-    path  "versions.yml"               , emit: version
+    path  "versions.yml"               , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     bcftools stats $options.args $vcf > ${prefix}.bcftools_stats.txt

modules/bcftools/view/main.nf

@@ -26,10 +26,9 @@ process BCFTOOLS_VIEW {
 
     output:
     tuple val(meta), path("*.gz") , emit: vcf
-    path "versions.yml"           , emit: version
+    path "versions.yml"           , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     def regions_file  = regions ? "--regions-file ${regions}" : ""
     def targets_file = targets ? "--targets-file ${targets}" : ""

modules/bedtools/bamtobed/main.nf

@@ -23,10 +23,9 @@ process BEDTOOLS_BAMTOBED {
 
     output:
     tuple val(meta), path("*.bed"), emit: bed
-    path  "versions.yml"          , emit: version
+    path  "versions.yml"          , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     bedtools \\

modules/bedtools/complement/main.nf

@@ -24,10 +24,9 @@ process BEDTOOLS_COMPLEMENT {
 
     output:
     tuple val(meta), path('*.bed'), emit: bed
-    path  "versions.yml"          , emit: version
+    path  "versions.yml"          , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     bedtools \\

modules/bedtools/genomecov/main.nf

@@ -25,10 +25,9 @@ process BEDTOOLS_GENOMECOV {
 
     output:
     tuple val(meta), path("*.${extension}"), emit: genomecov
-    path  "versions.yml"                   , emit: version
+    path  "versions.yml"                   , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     if (intervals.name =~ /\.bam/) {
         """

modules/bedtools/getfasta/main.nf

@@ -24,10 +24,9 @@ process BEDTOOLS_GETFASTA {
 
     output:
     path "*.fa"         , emit: fasta
-    path "versions.yml" , emit: version
+    path "versions.yml" , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${bed.baseName}${options.suffix}" : "${bed.baseName}"
     """
     bedtools \\

modules/bedtools/intersect/main.nf

@@ -24,10 +24,9 @@ process BEDTOOLS_INTERSECT {
 
     output:
     tuple val(meta), path("*.${extension}"), emit: intersect
-    path  "versions.yml"                   , emit: version
+    path  "versions.yml"                   , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     bedtools \\

modules/bedtools/makewindows/main.nf

@@ -24,10 +24,9 @@ process BEDTOOLS_MAKEWINDOWS {
 
     output:
     tuple val(meta), path("*.tab"), emit: tab
-    path "versions.yml"           , emit: version
+    path "versions.yml"           , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     def arg_input = use_bed ? "-b $regions" : "-g $regions"
     """

modules/bedtools/maskfasta/main.nf

@@ -24,10 +24,9 @@ process BEDTOOLS_MASKFASTA {
 
     output:
     tuple val(meta), path("*.fa"), emit: fasta
-    path "versions.yml"          , emit: version
+    path "versions.yml"          , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     bedtools \\

modules/bedtools/merge/main.nf

@@ -23,10 +23,9 @@ process BEDTOOLS_MERGE {
 
     output:
     tuple val(meta), path('*.bed'), emit: bed
-    path  "versions.yml"          , emit: version
+    path  "versions.yml"          , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     bedtools \\

modules/bedtools/slop/main.nf

@@ -24,10 +24,9 @@ process BEDTOOLS_SLOP {
 
     output:
     tuple val(meta), path("*.bed"), emit: bed
-    path  "versions.yml"          , emit: version
+    path  "versions.yml"          , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     bedtools \\

modules/bedtools/sort/main.nf

@@ -23,10 +23,9 @@ process BEDTOOLS_SORT {
 
     output:
     tuple val(meta), path('*.bed'), emit: bed
-    path  "versions.yml"          , emit: version
+    path  "versions.yml"          , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     bedtools \\

modules/bedtools/subtract/main.nf

@@ -23,10 +23,9 @@ process BEDTOOLS_SUBTRACT {
 
     output:
     tuple val(meta), path("*.bed"), emit: bed
-    path "versions.yml"           , emit: version
+    path "versions.yml"           , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     bedtools \\

modules/bismark/align/main.nf

@@ -26,10 +26,9 @@ process BISMARK_ALIGN {
     tuple val(meta), path("*bam")       , emit: bam
     tuple val(meta), path("*report.txt"), emit: report
     tuple val(meta), path("*fq.gz")     , optional:true, emit: unmapped
-    path "versions.yml"                 , emit: version
+    path "versions.yml"                 , emit: versions
 
     script:
-    def software   = getSoftwareName(task.process)
     def prefix     = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     def fastq      = meta.single_end ? reads : "-1 ${reads[0]} -2 ${reads[1]}"
     """

modules/bismark/deduplicate/main.nf

@@ -24,10 +24,9 @@ process BISMARK_DEDUPLICATE {
     output:
     tuple val(meta), path("*.deduplicated.bam")        , emit: bam
     tuple val(meta), path("*.deduplication_report.txt"), emit: report
-    path  "versions.yml"                               , emit: version
+    path  "versions.yml"                               , emit: versions
 
     script:
-    def software   = getSoftwareName(task.process)
     def prefix     = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     def seqtype    = meta.single_end ? '-s' : '-p'
     """

modules/bismark/genomepreparation/main.nf

@@ -23,10 +23,9 @@ process BISMARK_GENOMEPREPARATION {
 
     output:
     path "BismarkIndex" , emit: index
-    path "versions.yml" , emit: version
+    path "versions.yml" , emit: versions
 
     script:
-    def software   = getSoftwareName(task.process)
     """
     bismark_genome_preparation \\
         $options.args \\

modules/bismark/methylationextractor/main.nf

@@ -28,11 +28,10 @@ process BISMARK_METHYLATIONEXTRACTOR {
     tuple val(meta), path("*.cov.gz")              , emit: coverage
     tuple val(meta), path("*_splitting_report.txt"), emit: report
     tuple val(meta), path("*.M-bias.txt")          , emit: mbias
-    path "versions.yml"                            , emit: version
+    path "versions.yml"                            , emit: versions
 
     script:
     def seqtype  = meta.single_end ? '-s' : '-p'
-    def software = getSoftwareName(task.process)
     """
     bismark_methylation_extractor \\
         --bedGraph \\

modules/bismark/report/main.nf

@@ -23,10 +23,9 @@ process BISMARK_REPORT {
 
     output:
     tuple val(meta), path("*report.{html,txt}"), emit: report
-    path  "versions.yml"                       , emit: version
+    path  "versions.yml"                       , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     """
     bismark2report $options.args
 

modules/bismark/summary/main.nf

@@ -26,10 +26,9 @@ process BISMARK_SUMMARY {
 
     output:
     path  "*report.{html,txt}", emit: summary
-    path  "versions.yml"      , emit: version
+    path  "versions.yml"      , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     """
     bismark2summary
 

modules/blast/blastn/main.nf

@@ -24,10 +24,9 @@ process BLAST_BLASTN {
 
     output:
     tuple val(meta), path('*.blastn.txt'), emit: txt
-    path "versions.yml"                  , emit: version
+    path "versions.yml"                  , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     DB=`find -L ./ -name "*.ndb" | sed 's/.ndb//'`

modules/blast/makeblastdb/main.nf

@@ -23,10 +23,9 @@ process BLAST_MAKEBLASTDB {
 
     output:
     path 'blast_db'     , emit: db
-    path "versions.yml" , emit: version
+    path "versions.yml" , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     """
     makeblastdb \\
         -in $fasta \\

modules/bowtie/align/main.nf

@@ -25,11 +25,10 @@ process BOWTIE_ALIGN {
     output:
     tuple val(meta), path('*.bam'), emit: bam
     tuple val(meta), path('*.out'), emit: log
-    path  "versions.yml"          , emit: version
+    path  "versions.yml"          , emit: versions
     tuple val(meta), path('*fastq.gz'), optional:true, emit: fastq
 
     script:
-    def software  = getSoftwareName(task.process)
     def prefix    = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     def unaligned = params.save_unaligned ? "--un ${prefix}.unmapped.fastq" : ''
     def endedness = meta.single_end ? "$reads" : "-1 ${reads[0]} -2 ${reads[1]}"

modules/bowtie/build/main.nf

@@ -23,10 +23,9 @@ process BOWTIE_BUILD {
 
     output:
     path 'bowtie'       , emit: index
-    path "versions.yml" , emit: version
+    path "versions.yml" , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     """
     mkdir bowtie
     bowtie-build --threads $task.cpus $fasta bowtie/${fasta.baseName}

modules/bowtie2/align/main.nf

@@ -25,11 +25,10 @@ process BOWTIE2_ALIGN {
     output:
     tuple val(meta), path('*.bam'), emit: bam
     tuple val(meta), path('*.log'), emit: log
-    path  "versions.yml"          , emit: version
+    path  "versions.yml"          , emit: versions
     tuple val(meta), path('*fastq.gz'), optional:true, emit: fastq
 
     script:
-    def software   = getSoftwareName(task.process)
     def prefix     = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     if (meta.single_end) {
         def unaligned = params.save_unaligned ? "--un-gz ${prefix}.unmapped.fastq.gz" : ''

modules/bowtie2/build/main.nf

@@ -23,10 +23,9 @@ process BOWTIE2_BUILD {
 
     output:
     path 'bowtie2'      , emit: index
-    path "versions.yml" , emit: version
+    path "versions.yml" , emit: versions
 
     script:
-    def software  = getSoftwareName(task.process)
     """
     mkdir bowtie2
     bowtie2-build $options.args --threads $task.cpus $fasta bowtie2/${fasta.baseName}

modules/bwa/aln/main.nf

@@ -24,10 +24,9 @@ process BWA_ALN {
 
     output:
     tuple val(meta), path("*.sai"), emit: sai
-    path "versions.yml"           , emit: version
+    path "versions.yml"           , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
 
     if (meta.single_end) {

modules/bwa/index/main.nf

@@ -23,10 +23,9 @@ process BWA_INDEX {
 
     output:
     path "bwa"         , emit: index
-    path "versions.yml", emit: version
+    path "versions.yml", emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     """
     mkdir bwa
     bwa \\

modules/bwa/mem/main.nf

@@ -24,10 +24,9 @@ process BWA_MEM {
 
     output:
     tuple val(meta), path("*.bam"), emit: bam
-    path  "versions.yml"          , emit: version
+    path  "versions.yml"          , emit: versions
 
     script:
-    def software   = getSoftwareName(task.process)
     def prefix     = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     def read_group = meta.read_group ? "-R ${meta.read_group}" : ""
     """

modules/bwa/sampe/main.nf

@@ -24,10 +24,9 @@ process BWA_SAMPE {
 
     output:
     tuple val(meta), path("*.bam"), emit: bam
-    path "versions.yml"           , emit: version
+    path "versions.yml"           , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     def read_group = meta.read_group ? "-r ${meta.read_group}" : ""
 

modules/bwa/samse/main.nf

@@ -24,10 +24,9 @@ process BWA_SAMSE {
 
     output:
     tuple val(meta), path("*.bam"), emit: bam
-    path "versions.yml"           , emit: version
+    path "versions.yml"           , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     def read_group = meta.read_group ? "-r ${meta.read_group}" : ""
 

modules/bwamem2/index/main.nf

@@ -23,10 +23,9 @@ process BWAMEM2_INDEX {
 
     output:
     path "bwamem2"      , emit: index
-    path "versions.yml" , emit: version
+    path "versions.yml" , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     """
     mkdir bwamem2
     bwa-mem2 \\

modules/bwamem2/mem/main.nf

@@ -24,10 +24,9 @@ process BWAMEM2_MEM {
 
     output:
     tuple val(meta), path("*.bam"), emit: bam
-    path  "versions.yml"          , emit: version
+    path  "versions.yml"          , emit: versions
 
     script:
-    def software   = getSoftwareName(task.process)
     def prefix     = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     def read_group = meta.read_group ? "-R ${meta.read_group}" : ""
     """

modules/bwameth/align/main.nf

@@ -24,10 +24,9 @@ process BWAMETH_ALIGN {
 
     output:
     tuple val(meta), path("*.bam"), emit: bam
-    path  "versions.yml"          , emit: version
+    path  "versions.yml"          , emit: versions
 
     script:
-    def software   = getSoftwareName(task.process)
     def prefix     = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     def read_group = meta.read_group ? "-R ${meta.read_group}" : ""
     """

modules/bwameth/index/main.nf

@@ -23,10 +23,9 @@ process BWAMETH_INDEX {
 
     output:
     path "bwameth"      , emit: index
-    path "versions.yml" , emit: version
+    path "versions.yml" , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     """
     bwameth.py index $fasta
 

modules/cat/cat/main.nf

@@ -23,7 +23,7 @@ process CAT_CAT {
 
     output:
     path "${file_out}*" , emit: file_out
-    path "versions.yml" , emit: version
+    path "versions.yml" , emit: versions
 
     script:
     def file_list = files_in.collect { it.toString() }

modules/cat/fastq/main.nf

@@ -23,7 +23,7 @@ process CAT_FASTQ {
 
     output:
     tuple val(meta), path("*.merged.fastq.gz"), emit: reads
-    path "versions.yml"                       , emit: version
+    path "versions.yml"                       , emit: versions
 
     script:
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"

modules/chromap/chromap/main.nf

@@ -34,10 +34,9 @@ process CHROMAP_CHROMAP {
     tuple val(meta), path("*.bam")        , optional:true, emit: bam
     tuple val(meta), path("*.tagAlign.gz"), optional:true, emit: tagAlign
     tuple val(meta), path("*.pairs.gz")   , optional:true, emit: pairs
-    path "versions.yml"                                  , emit: version
+    path "versions.yml"                                  , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     def args     = options.args.tokenize()
 

modules/chromap/index/main.nf

@@ -25,10 +25,9 @@ process CHROMAP_INDEX {
 
     output:
     path "*.index"     , emit: index
-    path "versions.yml", emit: version
+    path "versions.yml", emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = fasta.baseName
     """
     chromap \\

modules/cnvkit/main.nf

@@ -28,10 +28,9 @@ process CNVKIT {
     tuple val(meta), path("*.cnn"), emit: cnn
     tuple val(meta), path("*.cnr"), emit: cnr
     tuple val(meta), path("*.cns"), emit: cns
-    path "versions.yml"           , emit: version
+    path "versions.yml"           , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     """
     cnvkit.py \\
         batch \\

modules/cooler/digest/main.nf

@@ -25,10 +25,9 @@ process COOLER_DIGEST {
 
     output:
     path "*.bed"                  , emit: bed
-    path "versions.yml"           , emit: version
+    path "versions.yml"           , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     """
     cooler digest \\
         $options.args \\

modules/cooler/dump/main.nf

@@ -23,10 +23,9 @@ process COOLER_DUMP {
 
     output:
     tuple val(meta), path("*.bedpe"), emit: bedpe
-    path "versions.yml"                  , emit: version
+    path "versions.yml"                  , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     cooler dump \\

modules/custom/dumpsoftwareversions/main.nf

@@ -22,9 +22,9 @@ process CUSTOM_DUMPSOFTWAREVERSIONS {
     path versions
 
     output:
-    path 'software_versions.yml'    , emit: yml
+    path "software_versions.yml"    , emit: yml
-    path 'software_versions_mqc.yml', emit: mqc_yml
+    path "software_versions_mqc.yml", emit: mqc_yml
-    path 'versions.yml'             , emit: versions
+    path "versions.yml"             , emit: versions
 
     script:
     """

modules/cutadapt/main.nf

@@ -24,10 +24,9 @@ process CUTADAPT {
     output:
     tuple val(meta), path('*.trim.fastq.gz'), emit: reads
     tuple val(meta), path('*.log')          , emit: log
-    path "versions.yml"                     , emit: version
+    path "versions.yml"                     , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     def trimmed  = meta.single_end ? "-o ${prefix}.trim.fastq.gz" : "-o ${prefix}_1.trim.fastq.gz -p ${prefix}_2.trim.fastq.gz"
     """

modules/damageprofiler/main.nf

@@ -25,10 +25,9 @@ process DAMAGEPROFILER {
 
     output:
     tuple val(meta), path("${prefix}"), emit: results
-    path  "versions.yml"              , emit: version
+    path  "versions.yml"              , emit: versions
 
     script:
-    def software   = getSoftwareName(task.process)
     prefix         = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
 
     """

modules/deeptools/computematrix/main.nf

@@ -25,10 +25,9 @@ process DEEPTOOLS_COMPUTEMATRIX {
     output:
     tuple val(meta), path("*.mat.gz") , emit: matrix
     tuple val(meta), path("*.mat.tab"), emit: table
-    path  "versions.yml"              , emit: version
+    path  "versions.yml"              , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     computeMatrix \\

modules/deeptools/plotfingerprint/main.nf

@@ -25,10 +25,9 @@ process DEEPTOOLS_PLOTFINGERPRINT {
     tuple val(meta), path("*.pdf")          , emit: pdf
     tuple val(meta), path("*.raw.txt")      , emit: matrix
     tuple val(meta), path("*.qcmetrics.txt"), emit: metrics
-    path  "versions.yml"                    , emit: version
+    path  "versions.yml"                    , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     def extend   = (meta.single_end && params.fragment_size > 0) ? "--extendReads ${params.fragment_size}" : ''
     """

modules/deeptools/plotheatmap/main.nf

@@ -24,10 +24,9 @@ process DEEPTOOLS_PLOTHEATMAP {
     output:
     tuple val(meta), path("*.pdf"), emit: pdf
     tuple val(meta), path("*.tab"), emit: table
-    path  "versions.yml"          , emit: version
+    path  "versions.yml"          , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     plotHeatmap \\

modules/deeptools/plotprofile/main.nf

@@ -24,10 +24,9 @@ process DEEPTOOLS_PLOTPROFILE {
     output:
     tuple val(meta), path("*.pdf"), emit: pdf
     tuple val(meta), path("*.tab"), emit: table
-    path  "versions.yml"          , emit: version
+    path  "versions.yml"          , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     plotProfile \\

modules/delly/call/main.nf

@@ -26,10 +26,9 @@ process DELLY_CALL {
     output:
     tuple val(meta), path("*.bcf"), emit: bcf
     tuple val(meta), path("*.csi"), emit: csi
-    path "versions.yml"           , emit: version
+    path "versions.yml"           , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     delly \\

modules/diamond/blastp/main.nf

@@ -26,10 +26,9 @@ process DIAMOND_BLASTP {
 
     output:
     tuple val(meta), path('*.txt'), emit: txt
-    path "versions.yml"           , emit: version
+    path "versions.yml"           , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     DB=`find -L ./ -name "*.dmnd" | sed 's/.dmnd//'`

modules/diamond/blastx/main.nf

@@ -26,10 +26,9 @@ process DIAMOND_BLASTX {
 
     output:
     tuple val(meta), path('*.txt'), emit: txt
-    path "versions.yml"           , emit: version
+    path "versions.yml"           , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     DB=`find -L ./ -name "*.dmnd" | sed 's/.dmnd//'`

modules/diamond/makedb/main.nf

@@ -25,10 +25,9 @@ process DIAMOND_MAKEDB {
 
     output:
     path "${fasta}.dmnd", emit: db
-    path "versions.yml" , emit: version
+    path "versions.yml" , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     """
     diamond \\
         makedb \\

modules/dragonflye/main.nf

@@ -27,10 +27,9 @@ process DRAGONFLYE {
     tuple val(meta), path("{flye,miniasm,raven}.fasta")                        , emit: raw_contigs
     tuple val(meta), path("{miniasm,raven}-unpolished.gfa"), optional:true     , emit: gfa
     tuple val(meta), path("flye-info.txt"), optional:true                      , emit: txt
-    path "versions.yml"                                                        , emit: version
+    path "versions.yml"                                                        , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def memory = task.memory.toGiga()
     """
     dragonflye \\

modules/dshbio/exportsegments/main.nf

@@ -23,10 +23,9 @@ process DSHBIO_EXPORTSEGMENTS {
 
     output:
     tuple val(meta), path("*.fa"), emit: fasta
-    path "versions.yml"              , emit: version
+    path "versions.yml"              , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     dsh-bio \\

modules/dshbio/filterbed/main.nf

@@ -23,10 +23,9 @@ process DSHBIO_FILTERBED {
 
     output:
     tuple val(meta), path("*.bed.gz"), emit: bed
-    path "versions.yml"              , emit: version
+    path "versions.yml"              , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     dsh-bio \\

modules/dshbio/filtergff3/main.nf

@@ -23,10 +23,9 @@ process DSHBIO_FILTERGFF3 {
 
     output:
     tuple val(meta), path("*.gff3.gz"), emit: gff3
-    path "versions.yml"               , emit: version
+    path "versions.yml"               , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     dsh-bio \\

modules/dshbio/splitbed/main.nf

@@ -23,10 +23,9 @@ process DSHBIO_SPLITBED {
 
     output:
     tuple val(meta), path("*.bed.gz"), emit: bed
-    path "versions.yml"              , emit: version
+    path "versions.yml"              , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     dsh-bio \\

modules/dshbio/splitgff3/main.nf

@@ -23,10 +23,9 @@ process DSHBIO_SPLITGFF3 {
 
     output:
     tuple val(meta), path("*.gff3.gz"), emit: gff3
-    path "versions.yml"               , emit: version
+    path "versions.yml"               , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     dsh-bio \\

modules/ensemblvep/main.nf

@@ -33,10 +33,9 @@ process ENSEMBLVEP {
     output:
     tuple val(meta), path("*.ann.vcf"), emit: vcf
     path "*.summary.html"             , emit: report
-    path "versions.yml"               , emit: version
+    path "versions.yml"               , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     dir_cache    = params.use_cache ? "\${PWD}/${cache}" : "/.vep"
     """

modules/expansionhunter/main.nf

@@ -25,10 +25,9 @@ process EXPANSIONHUNTER {
 
     output:
     tuple val(meta), path("*.vcf"), emit: vcf
-    path "versions.yml"           , emit: version
+    path "versions.yml"           , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     def gender = (meta.gender == 'male' || meta.gender == 1 || meta.gender == 'XY') ? "male" : "female"
     """

modules/fastani/main.nf

@@ -24,10 +24,9 @@ process FASTANI {
 
     output:
     tuple val(meta), path("*.ani.txt"), emit: ani
-    path "versions.yml"               , emit: version
+    path "versions.yml"               , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
 
     if (meta.batch_input) {

modules/fastp/main.nf

@@ -28,13 +28,12 @@ process FASTP {
     tuple val(meta), path('*.json')           , emit: json
     tuple val(meta), path('*.html')           , emit: html
     tuple val(meta), path('*.log')            , emit: log
-    path "versions.yml"                       , emit: version
+    path "versions.yml"                       , emit: versions
     tuple val(meta), path('*.fail.fastq.gz')  , optional:true, emit: reads_fail
     tuple val(meta), path('*.merged.fastq.gz'), optional:true, emit: reads_merged
 
     script:
     // Added soft-links to original fastqs for consistent naming in MultiQC
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     if (meta.single_end) {
         def fail_fastq = save_trimmed_fail ? "--failed_out ${prefix}.fail.fastq.gz" : ''

modules/fastqc/main.nf

@@ -24,7 +24,7 @@ process FASTQC {
     output:
     tuple val(meta), path("*.html"), emit: html
     tuple val(meta), path("*.zip") , emit: zip
-    path  "versions.yml"           , emit: version
+    path  "versions.yml"           , emit: versions
 
     script:
     // Add soft-links to original FastQs for consistent naming in pipeline
@@ -36,7 +36,7 @@ process FASTQC {
 
         cat <<-END_VERSIONS > versions.yml
         ${getProcessName(task.process)}:
-            fastqc: \$( fastqc --version | sed -e "s/FastQC v//g" )
+            ${getSoftwareName(task.process)}: \$( fastqc --version | sed -e "s/FastQC v//g" )
         END_VERSIONS
         """
     } else {
@@ -47,7 +47,7 @@ process FASTQC {
 
         cat <<-END_VERSIONS > versions.yml
         ${getProcessName(task.process)}:
-            fastqc: \$( fastqc --version | sed -e "s/FastQC v//g" )
+            ${getSoftwareName(task.process)}: \$( fastqc --version | sed -e "s/FastQC v//g" )
         END_VERSIONS
         """
     }

modules/fasttree/main.nf

@@ -22,10 +22,9 @@ process FASTTREE {
 
     output:
     path "*.tre",         emit: phylogeny
-    path "versions.yml" , emit: version
+    path "versions.yml" , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     """
     fasttree \\
         $options.args \\

modules/fgbio/callmolecularconsensusreads/main.nf

@@ -22,10 +22,9 @@ process FGBIO_CALLMOLECULARCONSENSUSREADS {
 
     output:
     tuple val(meta), path("*.bam"), emit: bam
-    path  "versions.yml"          , emit: version
+    path  "versions.yml"          , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     fgbio \\

modules/fgbio/sortbam/main.nf

@@ -22,10 +22,9 @@ process FGBIO_SORTBAM {
 
     output:
     tuple val(meta), path("*.bam"), emit: bam
-    path  "versions.yml"          , emit: version
+    path  "versions.yml"          , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     fgbio \\

modules/flash/main.nf

@@ -22,10 +22,9 @@ process FLASH {
 
     output:
     tuple val(meta), path("*.fastq.gz"), emit: reads
-    path "versions.yml"                , emit: version
+    path "versions.yml"                , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     flash \\

modules/gatk4/applybqsr/main.nf

@@ -27,10 +27,9 @@ process GATK4_APPLYBQSR {
 
     output:
     tuple val(meta), path("*.bam"), emit: bam
-    path "versions.yml"           , emit: version
+    path "versions.yml"           , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     def interval = intervals ? "-L ${intervals}" : ""
     """

modules/gatk4/baserecalibrator/main.nf

@@ -29,10 +29,9 @@ process GATK4_BASERECALIBRATOR {
 
     output:
     tuple val(meta), path("*.table"), emit: table
-    path "versions.yml"           , emit: version
+    path "versions.yml"           , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     def intervalsCommand = intervalsBed ? "-L ${intervalsBed}" : ""
     def sitesCommand = knownSites.collect{"--known-sites ${it}"}.join(' ')

modules/gatk4/bedtointervallist/main.nf

@@ -24,10 +24,9 @@ process GATK4_BEDTOINTERVALLIST {
 
     output:
     tuple val(meta), path('*.interval_list'), emit: interval_list
-    path  "versions.yml"                    , emit: version
+    path  "versions.yml"                    , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     gatk BedToIntervalList \\

modules/gatk4/createsequencedictionary/main.nf

@@ -23,10 +23,9 @@ process GATK4_CREATESEQUENCEDICTIONARY {
 
     output:
     path "*.dict"        , emit: dict
-    path "versions.yml"  , emit: version
+    path "versions.yml"  , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def avail_mem = 6
     if (!task.memory) {
         log.info '[GATK] Available memory not known - defaulting to 6GB. Specify process memory requirements to change this.'

modules/gatk4/fastqtosam/main.nf

@@ -23,10 +23,9 @@ process GATK4_FASTQTOSAM {
 
     output:
     tuple val(meta), path("*.bam"), emit: bam
-    path "versions.yml"           , emit: version
+    path "versions.yml"           , emit: versions
 
     script:
-    def software   = getSoftwareName(task.process)
     def prefix     = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     def read_files = meta.single_end ? "-F1 $reads" : "-F1 ${reads[0]} -F2 ${reads[1]}"
     """

modules/gatk4/getpileupsummaries/main.nf

@@ -26,10 +26,9 @@ process GATK4_GETPILEUPSUMMARIES {
 
     output:
     tuple val(meta), path('*.pileups.table'), emit: table
-    path "versions.yml"           , emit: version
+    path "versions.yml"           , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     def sitesCommand = ''
 

modules/gatk4/haplotypecaller/main.nf

@@ -27,10 +27,9 @@ process GATK4_HAPLOTYPECALLER {
     output:
     tuple val(meta), path("*.vcf.gz"), emit: vcf
     tuple val(meta), path("*.tbi")   , emit: tbi
-    path "versions.yml"              , emit: version
+    path "versions.yml"              , emit: versions
 
     script:
-    def software  = getSoftwareName(task.process)
     def prefix    = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     def avail_mem = 3
     if (!task.memory) {

modules/gatk4/intervallisttools/main.nf

@@ -23,10 +23,9 @@ process GATK4_INTERVALLISTTOOLS {
 
     output:
     tuple val(meta), path("*_split/*/*.interval_list"), emit: interval_list
-    path "versions.yml"           , emit: version
+    path "versions.yml"           , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
 

modules/gatk4/markduplicates/main.nf

@@ -24,10 +24,9 @@ process GATK4_MARKDUPLICATES {
     output:
     tuple val(meta), path("*.bam")    , emit: bam
     tuple val(meta), path("*.metrics"), emit: metrics
-    path "versions.yml"               , emit: version
+    path "versions.yml"               , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     gatk MarkDuplicates \\

modules/gatk4/mergebamalignment/main.nf

@@ -26,10 +26,9 @@ process GATK4_MERGEBAMALIGNMENT {
 
     output:
     tuple val(meta), path('*.bam'), emit: bam
-    path  "versions.yml"          , emit: version
+    path  "versions.yml"          , emit: versions
 
     script:
-    def software = getSoftwareName(task.process)
     def prefix   = options.suffix ? "${meta.id}${options.suffix}" : "${meta.id}"
     """
     gatk MergeBamAlignment \\