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:

Functions

The following functions may be used to modify text:

Key Description

f_now

formats the current timestamp

f_underscores

transforms . and - into _

f_dash

transforms . and _ into -

f_slash

transforms . and - into /

f_upper

invokes toUpperCase()

f_lower

invokes toLowerCase()

f_capitalize

invokes capitalize()

f_uncapitalize

invokes uncapitalize()

Example:

{{#f_now}}YYYY-MM-dd{{/f_now}}
{{#f_dash}}1.2.3{{/f_dash}}

Results in

2021-07-26
1-2-3

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

baseOutputDirectory

the base output directory (by default, "target" in Maven, "build" in Gradle, "out" in CLI)

outputDirectory

JReleaser’s output directory (always ends with "jreleaser")

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

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.

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 (semver)

projectVersionMinor

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

projectVersionPatch

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

projectVersionTag

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

projectVersionNumber

the version number (no build, no tag) of the project’s version (semver, java_runtime, java_module)

projectVersionOptional

the optional part (if any) of the project’s version (java_runtime)

projectVersionPrerelease

the prerelease part (if any) of the project’s version (java_runtime, java_module)

projectVersionBuild

the build part (if any) of the project’s version (semver, java_runtime, java_module)

projectVersionYear

the year part of the project’s version (calver)

projectVersionMonth

the month part (if any) of the project’s version (calver)

projectVersionDay

the day part (if any) of the project’s version (calver)

projectVersionWeek

the week part (if any) of the project’s version (calver)

projectVersionMicro

the micro part (if any) of the project’s version (calver)

projectVersionModifier

the modifier part of the project’s version (calver)

projectDescription

the project description

projectLongDescription

the project long description

projectWebsite

link to the project website

projectLicense

the project license, typically an SPDX identifier

projectLicenseUrl

the URL ofmthe project license

projectCopyright

the project copyright notice

projectVendor

the project’s vendor (if any)

projectDocsUrl

link to the project’s documentation

projectAuthorsBySpace

space separated list of author names

projectAuthorsByComma

comma 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)

projectJavaMainClass

the main class launched by the executable script launcher

There are convenient variants of the project’s version formatted with underscores (_) and dashes (-) instead of dots (.). These variants are:

  • projectVersionWithUnderscores

  • projectVersionWithDashes

  • projectEffectiveVersionWithUnderscores

  • projectEffectiveVersionWithDashes

  • projectVersionNumberWithUnderscores

  • projectVersionNumberWithDashes

Which would resolve to the following, assuming project.snapshot.label was set to {{projectVersionNumber}}.EarlyAccess.

Key Version

projectVersion

1.2.3-TAG

projectVersionWithUnderscores

1_2_3_TAG

projectVersionWithDashes

1-2-3-TAG

projectEffectiveVersionWithUnderscores

1_2_3_EarlyAccess

projectEffectiveVersionWithDashes

1-2-3-EarlyAccess

projectVersionNumberWithUnderscores

1_2_3

projectVersionNumberWithDashes

1-2-3

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}}

previousTagName

the tag to compare the release tag to, defaults to the previous tag

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

srcUrl

the URL to find a file in the repository

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

distributionExecutableExtension

executable extension on Windows. Defaults to bat.

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)

distributionJavaMainClass

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

artifactSize

the size (in bytes) of the artifact file

The following names match an artifact without explicit platform when uploaders are configured

Key Description

artifactDownloadUrl

the URL required to download the artifact

artifactDownload${Type}Url

the URL required to download the artifact, matching the typed uploader

artifactDownload${Type}${Name}Url

the URL required to download the artifact, matching the typed and named uploader

The following names match the first artifact in a distribution

Key Description

distributionUrl

the URL required to download the artifact

distributionSize

the size (in bytes) of the artifact file

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

distributionArtifactSize

the size (in bytes) of the artifact file

distributionArtifactPlatform

the artifact’s platform (if any)

The following names match the first artifact in a distribution when uploaders are configured

Key Description

distributionDownloadUrl

the URL required to download the artifact

distributionDownload${Type}Url

the URL required to download the artifact, matching the typed uploader

distributionDownload${Type}${Name}Url

the URL required to download the artifact, matching the typed and named uploader

Additional names become available when the artifact defines a platform

Key Description

artifact${Platform}Url

the URL required to download the artifact

artifact${Platform}Checksum${SHA}

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

artifact${Platform}FileName

the name of the artifact file

artifact${Platform}Name

the name of the artifact file without extension

artifact${Platform}Size

the size (in bytes) of the artifact file

Additional names become available when the artifact defines a platform and uploaders are configured

Key Description

artifact${Platform}DownloadUrl

the URL required to download the artifact

artifact${Platform}Download${Type}Url

the URL required to download the artifact, matching the typed uploader

artifact${Platform}Download${Type}${Name}Url

the URL required to download the artifact, matching the typed and named uploader

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

Thus, for artifacts defined as

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

checksum:
  algorithms:
    - MD5
    - SHA-256

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

[[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",
      "SHA-256"
    ]
  },

  "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>SHA-256</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('SHA-256')
  }
  distributions {
    app {
      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}

  • artifactSize

  • artifactMain: true

  • distributionUrl

  • distributionSize

  • distributionChecksummd5

  • distributionChecksumSha256

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

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

  • distributionArtifactSize

Platform specific artifact

  • artifactOsxUrl

  • artifactOsxChekcsumMd5

  • artifactOsxChekcsumSha256

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

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

  • artifactOsxSize

Artifactory

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

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

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

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

brewHashLivecheck

if custom livecheck instructions were specified

brewLivecheck

a list of strings for the livecheck block

brewCaskName

the cask name

brewCaskDisplayName

value for the cask’s desc field

brewCaskHasPkg

if the cask contains a .pkg artifact

brewCaskPkgName

value for the cask’s pkg field

brewCaskHasApp

if the cask contains a .dmg artifact

brewCaskAppName

value for the cask’s app field

brewCaskHasUninstall

if the cask defines a uninstall section

brewCaskUninstall

the uninstall section

brewCaskHasZap

if the cask defines a zap section

brewCaskZap

the zap section

brewCaskHasAppcast

if the cask defines an appcast URL

brewCaskAppcast

the appcast url

brewCaskHasBinary

if the cask contains a .zip artifact

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

chocolateyTitle

the title to use in the spec

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

the 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')
    }
  }
}

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')
    }
  }
}

GitHub 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')
    }
  }
}

Gitter

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

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

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

GoogleChat

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

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

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

Http

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

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

upload:
  http:
    app:
      extraProperties:
        # Key will be capitalized and prefixed
        # with `http`, i.e, `httpFoo`.
        foo: bar
[upload.http.app]
  # Key will be capitalized and prefixed
  # with `http`, i.e, `httpFoo`.
  extraProperties.foo = "bar"
{
  "upload": {
    "http": {
      "app": {
        "extraProperties": {
          // Key will be capitalized and prefixed
          // with `http`, i.e, `httpFoo`.
          "foo": "bar"
        }
      }
    }
  }
}
<jreleaser>
  <upload>
    <http>
      <app>
        <extraProperties>
          <!--
            Key will be capitalized and prefixed
            with `http`, i.e, `httpFoo`.
          -->
          <foo>bar</foo>
        </extraProperties>
      </app>
    </http>
  </upload>
</jreleaser>
jreleaser {
  upload {
    http {
      app {
        // Key will be capitalized and prefixed
        // with `http`, i.e, `httpFoo`.
        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')
    }
  }
}

Macports

The following names are related to Macports

Key Description

macportsRepositoryRepoUrl

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

macportsRepositoryRepoCloneUrl

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

macportsRevision

the port revision number

macportsCategories

categories separated by space

macportsMaintainers

formatted maintainers, one per line

macportsDistributionUrl

the download URL without the artifact file name

macportsJavaVersion

the Java version required by the port

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

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

packagers:
  macports:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `macports`, i.e, `macportsFoo`.
      foo: bar
[packagers.macports]
  # Key will be capitalized and prefixed
  # with `macports`, i.e, `macportsFoo`.
  extraProperties.foo = "bar"
{
  "packagers": {
    "macports": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `macports`, i.e, `macportsFoo`.
        "foo": "bar"
      }
    }
  }
}
<jreleaser>
  <packagers>
    <macports>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `macports`, i.e, `macportsFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </macports>
  </packagers>
</jreleaser>
jreleaser {
  packagers {
    macports {
      // Key will be capitalized and prefixed
      // with `macports`, i.e, `macportsFoo`.
      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')
    }
  }
}

S3

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

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

upload:
  s3:
    app:
      extraProperties:
        # Key will be capitalized and prefixed
        # with `s3`, i.e, `s3Foo`.
        foo: bar
[upload.s3.app]
  # Key will be capitalized and prefixed
  # with `s3`, i.e, `s3Foo`.
  extraProperties.foo = "bar"
{
  "upload": {
    "s3": {
      "app": {
        "extraProperties": {
          // Key will be capitalized and prefixed
          // with `s3`, i.e, `s3Foo`.
          "foo": "bar"
        }
      }
    }
  }
}
<jreleaser>
  <upload>
    <s3>
      <app>
        <extraProperties>
          <!--
            Key will be capitalized and prefixed
            with `s3`, i.e, `s3Foo`.
          -->
          <foo>bar</foo>
        </extraProperties>
      </app>
    </s3>
  </upload>
</jreleaser>
jreleaser {
  upload {
    s3 {
      app {
        // Key will be capitalized and prefixed
        // with `s3`, i.e, `s3Foo`.
        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')
    }
  }
}

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')
    }
  }
}

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')
    }
  }
}

spec

The following names are related to Spec

Key Description

specRepositoryRepoUrl

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

specRepositoryRepoCloneUrl

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

specRelease

the release number

specRequires

package requires as a List

specDirectories

List of directories to be created

specFiles

List of files to be installed

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

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

packagers:
  spec:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `spec`, i.e, `specFoo`.
      foo: bar
[packagers.spec]
  # Key will be capitalized and prefixed
  # with `spec`, i.e, `specFoo`.
  extraProperties.foo = "bar"
{
  "packagers": {
    "spec": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `spec`, i.e, `specFoo`.
        "foo": "bar"
      }
    }
  }
}
<jreleaser>
  <packagers>
    <spec>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `spec`, i.e, `specFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </spec>
  </packagers>
</jreleaser>
jreleaser {
  packagers {
    spec {
      // Key will be capitalized and prefixed
      // with `spec`, i.e, `specFoo`.
      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')
    }
  }
}

Telegram

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

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

announce:
  telegram:
    extraProperties:
      # Key will be capitalized and prefixed
      # with `telegram`, i.e, `telegramFoo`.
      foo: bar
[announce.telegram]
  # Key will be capitalized and prefixed
  # with `telegram`, i.e, `telegramFoo`.
  extraProperties.foo = "bar"
{
  "announce": {
    "telegram": {
      "extraProperties": {
        // Key will be capitalized and prefixed
        // with `telegram`, i.e, `telegramFoo`.
        "foo": "bar"
      }
    }
  }
}
<jreleaser>
  <announce>
    <telegram>
      <extraProperties>
        <!--
          Key will be capitalized and prefixed
          with `telegram`, i.e, `telegramFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>
    </telegram>
  </announce>
</jreleaser>
jreleaser {
  announce {
    telegram {
      // Key will be capitalized and prefixed
      // with `telegram`, i.e, `telegramFoo`.
      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')
    }
  }
}

Webhooks

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

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

announce:
  webhooks:
    myWebhook:
      extraProperties:
        # Key will be capitalized and prefixed
        # with `webhook`, i.e, `webhookFoo`.
        foo: bar
[announce.webhooks.myWebhook]
  # Key will be capitalized and prefixed
  # with `webhook`, i.e, `webhookFoo`.
  extraProperties.foo = "bar"
{
  "announce": {
    "webhooks": {
      "myWebhook": {
        "extraProperties": {
          // Key will be capitalized and prefixed
          // with `webhook`, i.e, `webhookFoo`.
          "foo": "bar"
        }
      }
    }
  }
}
<jreleaser>
  <announce>
    <webhooks>
      <myWebhook>
        <extraProperties>
          <!--
            Key will be capitalized and prefixed
            with `webhook`, i.e, `webhookFoo`.
          -->
          <foo>bar</foo>
        </extraProperties>
      </myWebhook>
    </webhooks>
  </announce>
</jreleaser>
jreleaser {
  announce {
    webhooks {
      myWebhook {
        // Key will be capitalized and prefixed
        // with `webhook`, i.e, `webhookFoo`.
        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')
    }
  }
}