Name Templates

Several fields in the JReleaser config file support templating. JReleaser makes use of the Mustache format for its templating support. Packagers rely on input files that also support templates. A template name can be used as {{name}}

The following is a list of pre-defined template names:

Environment

All environment variables are accessible with the Env. prefix, for example an environment variable named JAVA_OPTS becomes {{Env.JAVA_OPTS}}.

Additionally, every key/value from environment.properties becomes available

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

environment:
  properties:
    foo: bar
[environment]
  properties.foo = "bar"
{
  "environment": {
    "properties": {
      "foo": "bar"
    }
  }
}
<jreleaser>
  <environment>
    <properties>
      <foo>bar</foo>
    </properties>
  </environment>
</jreleaser>
jreleaser {
  environment {
    properties.put('foo', 'bar')
  }
}

The key foo becomes {{foo}} and will be evaluated to the String bar.

Build

The following names are related to the current build

Key Description

commitShortHash

head commit hash abbreviated to 7 characters

commitFullHash

head commit hash

timestamp

current timestamp with RFC3339 format

outputDirectory

JReleaser’s output directory

checksumDirectory

directory where checksums are found

signaturesDirectory

directory where signatures are found

assembleDirectory

directory where assembled distributions are found

artifactsDirectory

directory where transformed artifacts are found

prepareDirectory

base directory for preparing distributions

packageDirectory

base directory for packaging distributions

Project

The following names are related to Project

Key Description

projectName

the project name

projectNameCapitalized

the project name, capitalized, hyphens replaced by spaces.

projectVersion

the project version

projectEffectiveVersion

the project effective version

projectVersionMajor

the major number of the project’s version

projectVersionMinor

the minor number (if any) of the project’s version

projectVersionPatch

the patch number (if any) of the project’s version

projectVersionTag

the tag (if any) of the project’s version

projectVersionBuild

the build info (if any) of the project’s version

projectDescription

the project description

projectLongDescription

the project long description

projectWebsite

link to the project website

projectLicense

the project license, typically an SPDX identifier

projectCopyright

the project copyright notice

projectDocsUrl

link to the project’s documentation

projectAuthorsBySpace

space separated list of author names

projectAuthorsByComma

commma separated list of author names

projectTagsBySpace

space separate list of project tags

projectTagsByComma

comma separate list of project tags

projectJavaGroupId

the project groupId (Maven coordinates)

projectJavaArtifactId

the project artifactId (Maven coordinates)

projectJavaVersion

the project Java version (full)

projectJavaVersionMajor

the project Java version (major)

projectJavaVersionMinor

the project Java version (minor)

projectJavaVersionPatch

the project Java version (patch)

projectJavaVersionTag

the project Java version (tag)

projectJavaVersionBuild

the project Java version (build)

projectMainClass

the main class launched by the executable script launcher

The value of projectEffectiveVersion is calculated as follows:

  • if the project is snapshot the value becomes “early-access”. projectVersion remains unchanged.

  • if the project is release the value is the same as projectVersion.

Additionally, every key/value from project.extraProperties is mapped with project as key prefix and the capitalized key, such that

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

project:
  extraProperties:
    # Key will be capitalized and prefixed
    # with `project`, i.e, `projectFoo`.
    foo: bar
[project]
  # Key will be capitalized and prefixed
  # with `project`, i.e, `projectFoo`.
  extraProperties.foo = "bar"
{
  "project": {
    "extraProperties": {
      // Key will be capitalized and prefixed
      // with `project`, i.e, `projectFoo`.
      "foo": "bar"
    }
  }
}
<jreleaser>
  <project>
    <extraProperties>
      <!--
        Key will be capitalized and prefixed
        with `project`, i.e, `projectFoo`.
      -->
      <foo>bar</foo>
    </extraProperties>
  </project>
</jreleaser>
jreleaser {
  project {
    // Key will be capitalized and prefixed
    // with `project`, i.e, `projectFoo`.
    extraProperties.put('foo', 'bar')
  }
}

Additionally, every key/value from project.java.extraProperties is mapped with java as key prefix and the capitalized key, such that

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

project:
  java:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `java`, i.e, `javaFoo`.
      foo: bar
[project]
  # Key will be capitalized and prefixed
  # with `java`, i.e, `javaFoo`.
  java.extraProperties.foo = "bar"
{
  "project": {
    "java": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `java`, i.e, `javaFoo`.
        "foo": "bar"
      }
    }
  }
}
<jreleaser>
  <project>
    <java>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `java`, i.e, `javaFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </java>
  </project>
</jreleaser>
jreleaser {
  project {
    java {
      // Key will be capitalized and prefixed
      // with `java`, i.e, `javaFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

Platform

The following names are related to detected OS/Platform settings

Key Description

osName

normalized value of System.getProperty("os.name")

osArch

normalized value of System.getProperty("os.arch")

osPlatform

combination of ${osName}-${osArch}

osVersion

value of System.getProperty("os.version")

Release

The following names are related to Release

Key Description

repoHost

the Git host, i.e. "github.com"

repoOwner

the owner of the Git repository

repoName

the name of the Git repository

repoBranch

the branch on which the release is made

tagName

the tag being release, defaults to v{{projectVersion}}

releaseName

the release name, defaults to Release {{tagName}}

milestoneName

the milestone name/title, defaults to {{tagName}}

repoCanonicalName

the canonical name of the repository, {{repoOwner}}/{{repoName}}

repoUrl

the repository URL, https://{{repoHost}}/{{repoOwner}}/{{repoName}}

repoCloneUrl

the repository clone URL, https://{{repoHost}}/{{repoOwner}}/{{repoName}}.git

commitsUrl

the URL to find commits

releaseNotesUrl

the URL pointing to the release

latestReleaseUrl

the URL pointing to latest release

issueTrackerUrl

the URL of the issue tracker

reverseRepoHost

reversed Git host, i.e. "com.github"

changelogChanges

formatted commit changes

changelogContributors

list of unique names of all commit contributors

changelog

full changelog contents

The value of tagName is calculated as follows:

  • if the project is snapshot the value becomes “early-access”.

  • if the project is release the value remains unchanged.

Distribution

The following names are related to Distributions

Key Description

distributionName

the name of the distribution

distributionExecutable

the name of the executable script launcher

distributionTagsBySpace

space separate list of distribution tags

distributionTagsByComma

comma separate list of distribution tags

distributionJavaGroupId

the distribution groupId (Maven coordinates)

distributionJavaArtifactId

the distribution artifactId (Maven coordinates)

distributionJavaVersion

the distribution Java version (full)

distributionJavaVersionMajor

the distribution Java version (major)

distributionJavaVersionMinor

the distribution Java version (minor)

distributionJavaVersionPatch

the distribution Java version (patch)

distributionJavaVersionTag

the distribution Java version (tag)

distributionJavaVersionBuild

the distribution Java version (build)

distributionMainClass

the main class launched by the executable script launcher

Additionally, every key/value from distribution.<name>.extraProperties is mapped with distribution as key prefix and the capitalized key, such that

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

distributions:
  app:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `distribution`, i.e, `distributionFoo`.
      foo: bar
[distributions.app]
  # Key will be capitalized and prefixed
  # with `distribution`, i.e, `distributionFoo`.
  extraProperties.foo = "bar"
{
  "distributions": {
    "app": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `distribution`, i.e, `distributionFoo`.
        "foo": "bar"
      }
    }
  }
}
<jreleaser>
  <distributions>
    <app>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `distribution`, i.e, `distributionFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </app>
  </distributions>
</jreleaser>
jreleaser {
  distributions {
    app {
      // Key will be capitalized and prefixed
      // with `distribution`, i.e, `distributionFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

Additionally, every key/value from distribution.<name>.java.extraProperties is mapped with java as key prefix and the capitalized key, such that

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

distributions:
  app:
    java:
      extraProperties:
        # Key will be capitalized and prefixed
        # with `java`, i.e, `javaFoo`.
        foo: bar
[distributions.app]
  # Key will be capitalized and prefixed
  # with `java`, i.e, `javaFoo`.
  java.extraProperties.foo = "bar"
{
  "distributions": {
    "app": {
      "java": {
        "extraProperties": {
          // Key will be capitalized and prefixed
          // with `java`, i.e, `javaFoo`.
          "foo": "bar"
        }
      }
    }
  }
}
<jreleaser>
  <distributions>
    <app>
      <java>
        <extraProperties>
          <!--
            Key will be capitalized and prefixed
            with `java`, i.e, `javaFoo`.
          -->
          <foo>bar</foo>
        </extraProperties>
      </java>
    </app>
  </distributions>
</jreleaser>
jreleaser {
  distributions {
    app {
      java {
        // Key will be capitalized and prefixed
        // with `java`, i.e, `javaFoo`.
        extraProperties.put('foo', 'bar')
      }
    }
  }
}

Artifact

The following names identify an artifact without explicit platform

Key Description

artifactUrl

the URL required to download the artifact

artifactChecksum${SHA}

the matching checksum of the artifact’s file, per configured algorithm

artifactFileName

the name of the artifact file

artifactName

the name of the artifact file without extension

The following names match the first artifact in a distribution

Key Description

distributionUrl

the URL required to download the artifact

distributionChecksum${SHA}

the matching checksum of the artifact’s file, per configured algorithm

distributionArtifactFileName

the name of the artifact file

distributionArtifactName

the name of the artifact file without extension

Additional names become available when the artifact defines a platform

Key Description

artifact{{CapitalizedPlatform}}Url

the URL required to download the artifact

artifact{{CapitalizedPlatform}}Checksum${SHA}

the matching checksum of the artifact’s file, per configured algorithm

artifact{{CapitalizedPlatform}}FileName

the name of the artifact file

artifact{{CapitalizedPlatform}}Name

the name of the artifact file without extension

Additionally, every key/value from artifact.extraProperties is mapped with artifact as key prefix for the first artifact, and artifact{{CapitalizedPlatform}} for all artifacts, and the capitalized key.

Thus, for artifacts defined as

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

checksum:
  algorithms:
    - MD5
    - SHA256

distributions:
  app:
    artifacts:
      - path: path/to/{{distributionName}}-{{projectVersion}}.zip
        extraProperties:
          main: true
      - path: path/to/{{distributionName}}-{{projectVersion}}-mac.zip
        platform: osx
[checksum]
  algorithms = ["MD5", "SHA256"]

[[distributions.app.artifact]]
  path: "path/to/{{distributionName}}-{{projectVersion}}.zip"
  extraProperties.main = true

[[distributions.app.artifact]]
  path = "path/to/{{distributionName}}-{{projectVersion}}-mac.zip"
  platform = "osx"
{
  "checksums": {
    "algorithms": [
      "MD5",
      "SHA256"
    ]
  },

  "distributions": {
    "app": {
      "artifacts": [
        {
          "path": "path/to/{{distributionName}}-{{projectVersion}}.zip",
          "extraProperties":
          {
            "main": true
          }
        },
        {
          "path": "path/to/{{distributionName}}-{{projectVersion}}-mac.zip",
          "platform": "osx"
        }
      ],
    }
  }
}
<jreleaser>
  <checksum>
    <algorithms>
      <algorithm>MD5</algorithm>
      <algorithm>SHA256</algorithm>
    </algorithms>
  </checksum>
  <distributions>
    <app>
      <artifacts>
        <artifact>
          <path>path/to/${project.artifactId}-${project.version}.zip</path>
          <extraProperties>
            <main>true</main>
          </extraProperties>
        </artifact>
        <artifact>
          <path>path/to/${project.artifactId}-${project.version}-mac.zip</path>
          <platform>osx</platform>
        </artifact>
      </artifacts>
    </app>
  </distributions>
</jreleaser>
jreleaser {
  checksum {
    algorithm('MD5')
    algorithm('SHA256')
  }
  distributions {
    app {
      artifacts {
        artifact {
          path = "path/to/${project.name}-${project.version}.zip"
          extraProperties.put("main", true)
        }
        artifact {
          path = "path/to/${project.name}-${project.version}-mac.zip"
          platform = 'osx'
        }
      }
    }
  }
}

The following names will be calculated:

1st artifact

  • artifactUrl

  • artifactChecksumMd5

  • artifactChecksumSha256

  • artifactFileName: ${project.name}-${project.version}.zip

  • artifactName: ${project.name}-${project.version}

  • artifactMain: true

  • distributionUrl

  • distributionChecksummd5

  • distributionChecksumSha256

  • distributionArtifactFileName: ${project.name}-${project.version}.zip

  • distributionArtifactName: ${project.name}-${project.version}

Platform specific artifact

  • artifactOsxUrl

  • artifactOsxChekcsumMd5

  • artifactOsxChekcsumSha256

  • artifactOsxFileName: ${project.name}-${project.version}-mac.zip

  • artifactOsxName: ${project.name}-${project.version}-mac

Brew

The following names are related to Homebrew

Key Description

brewTapRepoUrl

the tap repository URL, https://{{repoHost}}/{{repoOwner}}/{{repoName}}

brewTapRepoCloneUrl

the tap repository clone URL, https://{{repoHost}}/{{repoOwner}}/{{repoName}}.git

brewFormulaName

the formula name. Defaults to {{projectNameCapitalized}}

brewDependencies

a map of key/value pairs

Additionally, every key/value from brew.extraProperties is mapped with brew as key prefix and the capitalized key, such that

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

packagers:
  brew:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `brew`, i.e, `brewFoo`.
      foo: bar
[packagers.brew]
  # Key will be capitalized and prefixed
  # with `brew`, i.e, `brewFoo`.
  extraProperties.foo = "bar"
{
  "packagers": {
    "brew": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `brew`, i.e, `brewFoo`.
        "foo": "bar"
      }
    }
  }
}
<jreleaser>
  <packagers>
    <brew>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `brew`, i.e, `brewFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </brew>
  </packagers>
</jreleaser>
jreleaser {
  packagers {
    brew {
      // Key will be capitalized and prefixed
      // with `brew`, i.e, `brewFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

Chocolatey

The following names are related to Chocolatey

Key Description

chocolateyUsername

the name of the Chocolatey username

chocolateyBucketRepoUrl

the bucket repository URL, https://{{repoHost}}/{{repoOwner}}/{{repoName}}

chocolateyBucketRepoCloneUrl

the bucket clone repository URL, https://{{repoHost}}/{{repoOwner}}/{{repoName}}.git

Additionally, every key/value from chocolatey.extraProperties is mapped with chocolatey as key prefix and the capitalized key, such that

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

packagers:
  chocolatey:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `chocolatey`, i.e, `chocolateyFoo`.
      foo: bar
[packagers.chocolatey]
  # Key will be capitalized and prefixed
  # with `chocolatey`, i.e, `chocolateyFoo`.
  extraProperties.foo = "bar"
{
  "packagers": {
    "chocolatey": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `chocolatey`, i.e, `chocolateyFoo`.
        "foo": "bar"
      }
    }
  }
}
<jreleaser>
  <packagers>
    <chocolatey>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `chocolatey`, i.e, `chocolateyFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </chocolatey>
  </packagers>
</jreleaser>
jreleaser {
  packagers {
    chocolatey {
      // Key will be capitalized and prefixed
      // with `chocolatey`, i.e, `chocolateyFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

Docker

The following names are related to configuration:packagers/homedocker.adoc

Key Description

dockerBaseImage

the base Docker image

dockerLabels

a list of formatted labels

dockerSpecName

tha name of the current Docker spec

Additionally, every key/value from docker.extraProperties is mapped with docker as key prefix and the capitalized key, such that

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

packagers:
  docker:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `docker`, i.e, `dockerFoo`.
      foo: bar
[packagers.docker]
  # Key will be capitalized and prefixed
  # with `docker`, i.e, `dockerFoo`.
  extraProperties.foo = "bar"
{
  "packagers": {
    "docker": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `docker`, i.e, `dockerFoo`.
        "foo": "bar"
      }
    }
  }
}
<jreleaser>
  <packagers>
    <docker>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `docker`, i.e, `dockerFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </docker>
  </packagers>
</jreleaser>
jreleaser {
  packagers {
    docker {
      // Key will be capitalized and prefixed
      // with `docker`, i.e, `dockerFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

JBang

The following names are related to JBang

Key Description

jbangCatalogRepoUrl

the catalog repository URL, https://{{repoHost}}/{{repoOwner}}/{{repoName}}

jbangCatalogRepoCloneUrl

the catalog repository clone URL, https://{{repoHost}}/{{repoOwner}}/{{repoName}}.git

jbangAliasName

the name of the jbang alias, {{distributionExecutable}} or {{distributionExecutable}}-snapshot

jbangScriptName

the name of the jbang script file, {{distributionExecutable}} or {{distributionExecutable}}_snapshot

jbangDistributionGA

calculated Maven coordinates for https://jitpack.io

single

{{reverseRepoHost}}.{{repoOwner}}:{{distributionArtifactId}

multi

{{reverseRepoHost}}.{{repoOwner}}.{{repoName}}:{{distributionArtifactId}

Additionally, every key/value from jbang.extraProperties is mapped with jbang as key prefix and the capitalized key, such that

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

packagers:
  jbang:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `jbang`, i.e, `jbangFoo`.
      foo: bar
[packagers.jbang]
  # Key will be capitalized and prefixed
  # with `jbang`, i.e, `jbangFoo`.
  extraProperties.foo = "bar"
{
  "packagers": {
    "jbang": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `jbang`, i.e, `jbangFoo`.
        "foo": "bar"
      }
    }
  }
}
<jreleaser>
  <packagers>
    <jbang>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `jbang`, i.e, `jbangFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </jbang>
  </packagers>
</jreleaser>
jreleaser {
  packagers {
    jbang {
      // Key will be capitalized and prefixed
      // with `jbang`, i.e, `jbangFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

Scoop

The following names are related to Scoop

Key Description

scoopBucketRepoUrl

the bucket repository URL, https://{{repoHost}}/{{repoOwner}}/{{repoName}}

scoopBucketRepoCloneUrl

the bucket repository clone URL, https://{{repoHost}}/{{repoOwner}}/{{repoName}}.git

scoopCheckverUrl

the URL used to check for a release version

scoopAutoupdateUrl

the URL pattern used to update the package

Additionally, every key/value from scoop.extraProperties is mapped with scoop as key prefix and the capitalized key, such that

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

packagers:
  scoop:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `scoop`, i.e, `scoopFoo`.
      foo: bar
[packagers.scoop]
  # Key will be capitalized and prefixed
  # with `scoop`, i.e, `scoopFoo`.
  extraProperties.foo = "bar"
{
  "packagers": {
    "scoop": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `scoop`, i.e, `scoopFoo`.
        "foo": "bar"
      }
    }
  }
}
<jreleaser>
  <packagers>
    <scoop>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `scoop`, i.e, `scoopFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </scoop>
  </packagers>
</jreleaser>
jreleaser {
  packagers {
    scoop {
      // Key will be capitalized and prefixed
      // with `scoop`, i.e, `scoopFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

Snap

The following names are related to Snap

Key Description

snapRepoUrl

the snap repository URL, https://{{repoHost}}/{{repoOwner}}/{{repoName}}

snapRepoCloneUrl

the snap repository clone URL, https://{{repoHost}}/{{repoOwner}}/{{repoName}}.git

snapBase

the snap base

snapGrade

the snap grade

snapConfinement

the snap confinement

snapHasPlugs

a boolean, when there snap defines plugs

snapPlugs

a list of Plugs

snapHasSlots

a boolean, when the snap defines slots

snapSlots

a list of Slots

snapHasLocalPlugs

a boolean, when the snap defines plug names

snapLocalPlugs

a list of plug names

snapHasLocalSlots

a boolean, when the snap defines slot names

snapLocalSlots

a list of slot names

A Plug defines the following fields

Key Description

name

the plug’s name

attributes

a map of key/value attributes

A Slot defines the following fields

Key Description

name

the slot’s name

attributes

a map of key/value attributes

reads

a list of read names

writes

a list of write names

hasReads

a boolean, when the slot defines reads

hasWrites

a boolean, when the slot defines writes

Additionally, every key/value from snap.extraProperties is mapped with snap as key prefix and the capitalized key, such that

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

packagers:
  snap:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `snap`, i.e, `snapFoo`.
      foo: bar
[packagers.snap]
  # Key will be capitalized and prefixed
  # with `snap`, i.e, `snapFoo`.
  extraProperties.foo = "bar"
{
  "packagers": {
    "snap": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `snap`, i.e, `snapFoo`.
        "foo": "bar"
      }
    }
  }
}
<jreleaser>
  <packagers>
    <snap>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `snap`, i.e, `snapFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </snap>
  </packagers>
</jreleaser>
jreleaser {
  packagers {
    snap {
      // Key will be capitalized and prefixed
      // with `snap`, i.e, `snapFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

Discord

Every key/value from discord.extraProperties is mapped with discord as key prefix and the capitalized key, such that

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

announce:
  discord:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `discord`, i.e, `discordFoo`.
      foo: bar
[announce.discord]
  # Key will be capitalized and prefixed
  # with `discord`, i.e, `discordFoo`.
  extraProperties.foo = "bar"
{
  "announce": {
    "discord": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `discord`, i.e, `discordFoo`.
        "foo": "bar"
      }
    }
  }
}
<jreleaser>
  <announce>
    <discord>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `discord`, i.e, `discordFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </discord>
  </announce>
</jreleaser>
jreleaser {
  announce {
    discord {
      // Key will be capitalized and prefixed
      // with `discord`, i.e, `discordFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

Discussions

Every key/value from discussions.extraProperties is mapped with discussions as key prefix and the capitalized key, such that

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

announce:
  discussions:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `discussions`, i.e, `discussionsFoo`.
      foo: bar
[announce.discussions]
  # Key will be capitalized and prefixed
  # with `discussions`, i.e, `discussionsFoo`.
  extraProperties.foo = "bar"
{
  "announce": {
    "discussions": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `discussions`, i.e, `discussionsFoo`.
        "foo": "bar"
      }
    }
  }
}
<jreleaser>
  <announce>
    <discussions>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `discussions`, i.e, `discussionsFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </discussions>
  </announce>
</jreleaser>
jreleaser {
  announce {
    discussions {
      // Key will be capitalized and prefixed
      // with `discussions`, i.e, `discussionsFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

Mail

Every key/value from mail.extraProperties is mapped with mail as key prefix and the capitalized key, such that

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

announce:
  mail:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `mail`, i.e, `mailFoo`.
      foo: bar
[announce.mail]
  # Key will be capitalized and prefixed
  # with `mail`, i.e, `mailFoo`.
  extraProperties.foo = "bar"
{
  "announce": {
    "mail": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `mail`, i.e, `mailFoo`.
        "foo": "bar"
      }
    }
  }
}
<jreleaser>
  <announce>
    <mail>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `mail`, i.e, `mailFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </mail>
  </announce>
</jreleaser>
jreleaser {
  announce {
    mail {
      // Key will be capitalized and prefixed
      // with `mail`, i.e, `mailFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

Mastodon

Every key/value from mastodon.extraProperties is mapped with mastodon as key prefix and the capitalized key, such that

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

announce:
  mastodon:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `mastodon`, i.e, `mastodonFoo`.
      foo: bar
[announce.mastodon]
  # Key will be capitalized and prefixed
  # with `mastodon`, i.e, `mastodonFoo`.
  extraProperties.foo = "bar"
{
  "announce": {
    "mastodon": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `mastodon`, i.e, `mastodonFoo`.
        "foo": "bar"
      }
    }
  }
}
<jreleaser>
  <announce>
    <mastodon>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `mastodon`, i.e, `mastodonFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </mastodon>
  </announce>
</jreleaser>
jreleaser {
  announce {
    mastodon {
      // Key will be capitalized and prefixed
      // with `mastodon`, i.e, `mastodonFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

Mattermost

Every key/value from mattermost.extraProperties is mapped with mattermost as key prefix and the capitalized key, such that

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

announce:
  mattermost:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `mattermost`, i.e, `mattermostFoo`.
      foo: bar
[announce.mattermost]
  # Key will be capitalized and prefixed
  # with `mattermost`, i.e, `mattermostFoo`.
  extraProperties.foo = "bar"
{
  "announce": {
    "mattermost": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `mattermost`, i.e, `mattermostFoo`.
        "foo": "bar"
      }
    }
  }
}
<jreleaser>
  <announce>
    <mattermost>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `mattermost`, i.e, `mattermostFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </mattermost>
  </announce>
</jreleaser>
jreleaser {
  announce {
    mattermost {
      // Key will be capitalized and prefixed
      // with `mattermost`, i.e, `mattermostFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

Sdkman

Every key/value from sdkman.extraProperties is mapped with sdkman as key prefix and the capitalized key, such that

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

announce:
  sdkman:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `sdkman`, i.e, `sdkmanFoo`.
      foo: bar
[announce.sdkman]
  # Key will be capitalized and prefixed
  # with `sdkman`, i.e, `sdkmanFoo`.
  extraProperties.foo = "bar"
{
  "announce": {
    "sdkman": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `sdkman`, i.e, `sdkmanFoo`.
        "foo": "bar"
      }
    }
  }
}
<jreleaser>
  <announce>
    <sdkman>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `sdkman`, i.e, `sdkmanFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </sdkman>
  </announce>
</jreleaser>
jreleaser {
  announce {
    sdkman {
      // Key will be capitalized and prefixed
      // with `sdkman`, i.e, `sdkmanFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

Slack

Every key/value from slack.extraProperties is mapped with slack as key prefix and the capitalized key, such that

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

announce:
  slack:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `slack`, i.e, `slackFoo`.
      foo: bar
[announce.slack]
  # Key will be capitalized and prefixed
  # with `slack`, i.e, `slackFoo`.
  extraProperties.foo = "bar"
{
  "announce": {
    "slack": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `slack`, i.e, `slackFoo`.
        "foo": "bar"
      }
    }
  }
}
<jreleaser>
  <announce>
    <slack>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `slack`, i.e, `slackFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </slack>
  </announce>
</jreleaser>
jreleaser {
  announce {
    slack {
      // Key will be capitalized and prefixed
      // with `slack`, i.e, `slackFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

Teams

Every key/value from teams.extraProperties is mapped with teams as key prefix and the capitalized key, such that

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

announce:
  teams:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `teams`, i.e, `teamsFoo`.
      foo: bar
[announce.teams]
  # Key will be capitalized and prefixed
  # with `teams`, i.e, `teamsFoo`.
  extraProperties.foo = "bar"
{
  "announce": {
    "teams": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `teams`, i.e, `teamsFoo`.
        "foo": "bar"
      }
    }
  }
}
<jreleaser>
  <announce>
    <teams>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `teams`, i.e, `teamsFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </teams>
  </announce>
</jreleaser>
jreleaser {
  announce {
    teams {
      // Key will be capitalized and prefixed
      // with `teams`, i.e, `teamsFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

Twitter

Every key/value from twitter.extraProperties is mapped with twitter as key prefix and the capitalized key, such that

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

announce:
  twitter:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `twitter`, i.e, `twitterFoo`.
      foo: bar
[announce.twitter]
  # Key will be capitalized and prefixed
  # with `twitter`, i.e, `twitterFoo`.
  extraProperties.foo = "bar"
{
  "announce": {
    "twitter": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `twitter`, i.e, `twitterFoo`.
        "foo": "bar"
      }
    }
  }
}
<jreleaser>
  <announce>
    <twitter>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `twitter`, i.e, `twitterFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </twitter>
  </announce>
</jreleaser>
jreleaser {
  announce {
    twitter {
      // Key will be capitalized and prefixed
      // with `twitter`, i.e, `twitterFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}

Zulip

Every key/value from zulip.extraProperties is mapped with zulip as key prefix and the capitalized key, such that

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

announce:
  zulip:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `zulip`, i.e, `zulipFoo`.
      foo: bar
[announce.zulip]
  # Key will be capitalized and prefixed
  # with `zulip`, i.e, `zulipFoo`.
  extraProperties.foo = "bar"
{
  "announce": {
    "zulip": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `zulip`, i.e, `zulipFoo`.
        "foo": "bar"
      }
    }
  }
}
<jreleaser>
  <announce>
    <zulip>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `zulip`, i.e, `zulipFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </zulip>
  </announce>
</jreleaser>
jreleaser {
  announce {
    zulip {
      // Key will be capitalized and prefixed
      // with `zulip`, i.e, `zulipFoo`.
      extraProperties.put('foo', 'bar')
    }
  }
}