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_capitalize

invokes capitalize()

f_checksum_md2

file checksum with the given algorithm

f_checksum_md5

file checksum with the given algorithm

f_checksum_rmd160

file checksum with the given algorithm

f_checksum_sha1

file checksum with the given algorithm

f_checksum_sha256

file checksum with the given algorithm

f_checksum_sha3-224

file checksum with the given algorithm

f_checksum_sha3-256

file checksum with the given algorithm

f_checksum_sha3-384

file checksum with the given algorithm

f_checksum_sha3-512

file checksum with the given algorithm

f_checksum_sha384

file checksum with the given algorithm

f_checksum_sha512

file checksum with the given algorithm

f_chop

remove the last character from a String

f_dash

transforms . and _ into -

f_delete_whitespace

deletes all whitespaces from a String

f_escape_csv

returns a String value for a CSV column enclosed in double quotes, if required

f_escape_ecma_script

escapes the characters in a String using EcmaScript String rules

f_escape_html3

escapes the characters in a String using HTML entities

f_escape_html4

escapes the characters in a String using HTML entities

f_escape_java

escapes the characters in a String using Java String rules

f_escape_json

escapes the characters in a String using Json String rules

f_escape_xml10

escapes the characters in a String using XML entities

f_escape_xml11

escapes the characters in a String using XML entities

f_escape_xsi

escapes the characters in a String using XSI rules

f_file_exists

checks if the given file exists

f_file_read

reads a file and includes its contents, verbatim

f_file_size

the size of the file, in bytes

f_json

converts the given input into JSON

f_lower

invokes toLowerCase()

f_md2html

transforms its input from Markdown into HTML

f_normalize_whitespace

similar to xpath/#function-normalize-space

f_now

formats the current timestamp (in local timezone)

f_now_gmt

formats the current timestamp (in GMT timezone)

f_recursive_eval

evaluates templates found in the input

f_release_download_url

formats its input as a link to a release asset

f_reverse

reverses a String

f_slash

transforms . and - into /

f_strip

strips whitespace from the start and end of a String

f_swapcase

swaps the case of a String changing upper and title case to lower case, and lower case to upper case

f_trim

removes whitespace from the input

f_uncapitalize

invokes uncapitalize()

f_underscores

transforms . and - into _

f_upper

invokes toUpperCase()

The f_release_download_url function expects the name of a release asset and creates a link to said asset. The default format is Markdown. Use a prefix such as md:, adoc:, or html: to indicate a different format. You may also set a different value for the link such that

Input filename linkname format

foo.zip

foo.zip

foo.zip

md

bar:foo.zip

foo.zip

bar

md

adoc:bar:foo.zip

foo.zip

bar

adoc

html:foo.zip

foo.zip

foo.zip

html

Example:

{{#f_now}}YYYY-MM-dd{{/f_now}}
{{#f_dash}}1.2.3{{/f_dash}}
{{#f_release_download_url}}jreleaser-{{projectEffectiveVersion}}.zip{{/f_release_download_url}}
{{#f_release_download_url}}asc:jreleaser-{{projectEffectiveVersion}}.zip.asc{{/f_release_download_url}}
{{#f_release_download_url}}md:jreleaser-{{projectEffectiveVersion}}.zip{{/f_release_download_url}}
{{#f_release_download_url}}adoc:jreleaser-{{projectEffectiveVersion}}.zip{{/f_release_download_url}}
{{#f_release_download_url}}html:jreleaser-{{projectEffectiveVersion}}.zip{{/f_release_download_url}}

Results in

2021-07-26
1-2-3
[jreleaser-1.14.0.zip](https://github.com/jreleaser/jreleaser/releases/download/v1.14.0/jreleaser-1.14.0.zip)
[asc](https://github.com/jreleaser/jreleaser/releases/download/v1.14.0/jreleaser-1.14.0.zip.asc)
[jreleaser-1.14.0.zip](https://github.com/jreleaser/jreleaser/releases/download/v1.14.0/jreleaser-1.14.0.zip)
link:https://github.com/jreleaser/jreleaser/releases/download/v1.14.0/jreleaser-1.14.0.zip[jreleaser-1.14.0.zip]
<a href="https://github.com/jreleaser/jreleaser/releases/download/v1.14.0/jreleaser-1.14.0.zip">jreleaser-1.14.0.zip</a>

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

basedir

the base directory where JReleaser is invoked

command

the invoked JReleaser command

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

projectStereotype

the project stereotype

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

projectLinkHomepage

link to the project’s website

projectLinkDocumentation

link to the project’s documentation

projectLinkLicense

link to the project’s license

projectLinkBugTracker

link to the project’s issue tracker

projectLinkVcsBrowser

link to the project’s source control

projectLinkFaq

link to the project’s FAQ

projectLinkHelp

link to the project’s help page

projectLinkDonation

link to the project’s donations page

projectLinkTranslate

link to the project’s translations page

projectLinkContact

link to the project’s contact page

projectLinkContribute

link to the project’s contribution page

projectLicense

the project license, typically an SPDX identifier

projectInceptionYear

year when the project started

projectCopyright

the project copyright notice

projectVendor

the project’s vendor (if any)

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

Model

The resolved model is accessible with the Model. prefix. For example, resolving the project’s version may be done with the following template: {{ Model.project.version }}.

Be aware that some properties may not be resolvable or their resolution may cause a recursive loop. Prefer explicit name templates over directly accessing model properties.

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

osVersion

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

osPlatform

combination of ${osName}-${osArch}

osPlatformReplaced

osPlatform after platform replacements have been applied

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.

Changelog

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

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

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

Distribution

The following names are related to Distributions

Key Description

distributionName

the name of the distribution

distributionStereotype

the stereotype of the distribution

distributionExecutableName

the name of the executable without extension

distributionExecutableUnix

the name of the executable with unix extension

distributionExecutableWindows

the name of the executable with windows extension

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

distributionJavaMainJar

the main jar launched by the executable script launcher

distributionJavaMainModule

the module used by the executable script launcher

distributionJavaJvmOptionsUniversal

JVM custom settings used by the executable script launcher

distributionJavaJvmOptionsUnix

JVM custom settings used by the executable script launcher

distributionJavaJvmOptionsLinux

JVM custom settings used by the executable script launcher

distributionJavaJvmOptionsOsx

JVM custom settings used by the executable script launcher

distributionJavaJvmOptionsWindows

JVM custom settings used by the executable script launcher

distributionJavaEnvironmentVariablesUniversal

Environment variables used by the executable script launcher

distributionJavaEnvironmentVariablesUnix

Environment variables used by the executable script launcher

distributionJavaEnvironmentVariablesLinux

Environment variables used by the executable script launcher

distributionJavaEnvironmentVariablesOsx

Environment variables used by the executable script launcher

distributionJavaEnvironmentVariablesWindows

Environment variables used 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

artifactFile

the name of the artifact file

artifactFileName

the name of the artifact file without extension

artifactFileExtension

the extension of the artifact’s file

artifactFileFormat

the extension without the leading dot

artifactRootEntryName

the name of the artifact’s root entry

artifactSize

the size (in bytes) of the artifact file

artifactName

matches artifactId (GAV coordinates)

artifactVersion

matches version (GAV coordinates)

artifactPlatform

the artifact’s platform (if any)

artifactPlatformReplaced

the artifact’s replaced platform (if any)

artifactOs

the os component of the artifact’s platform (if any)

artifactArch

the arch component of the artifact’s platform (if any)

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

distributionArtifactFile

the name of the artifact file

distributionArtifactFileName

the name of the artifact file without extension

distributionArtifactFileExtension

the extension of the artifact’s file

distributionArtifactFileFormat

the extension without the leading dot

distributionArtifactRootEntryName

the name of the artifact’s root entry

distributionArtifactSize

the size (in bytes) of the artifact file

distributionArtifactName

matches artifactId (GAV coordinates)

distributionArtifactVersion

matches version (GAV coordinates)

distributionArtifactPlatform

the artifact’s platform (if any)

distributionArtifactPlatformReplaced

the artifact’s replaced platform (if any)

distributionArtifactOs

the os component of the artifact’s platform (if any)

distributionArtifactArch

the arch component of 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}File

the name of the artifact file

artifact${Platform}FileName

the name of the artifact file without extension

artifact${Platform}FileExtension

the extension of the artifact’s file

artifact${Platform}FileFormat

the extension without the leading dot

artifact${Platform}RootEntryName

the name of the artifact’s root entry

artifact${Platform}Size

the size (in bytes) of the artifact file

artifact${Platform}Name

matches artifactId (GAV coordinates)

artifact${Platform}Version

matches version (GAV coordinates)

artifact${Platform}Platform

the artifact’s platform (if any)

artifact${Platform}PlatformReplaced

the artifact’s replaced platform (if any)

artifact${Platform}Os

the os component of the artifact’s platform (if any)

artifact${Platform}Arch

the arch component of the artifact’s platform (if any)

artifact${PlatformReplaced}Url

the URL required to download the artifact

artifact${PlatformReplaced}Checksum${SHA}

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

artifact${PlatformReplaced}File

the name of the artifact file

artifact${PlatformReplaced}FileName

the name of the artifact file without extension

artifact${PlatformReplaced}FileExtension

the extension of the artifact’s file

artifact${PlatformReplaced}FileFormat

the extension without the leading dot

artifact${PlatformReplaced}RootEntryName

the name of the artifact’s root entry

artifact${PlatformReplaced}Size

the size (in bytes) of the artifact file

artifact${PlatformReplaced}Name

matches artifactId (GAV coordinates)

artifact${PlatformReplaced}Version

matches version (GAV coordinates)

artifact${PlatformReplaced}Platform

the artifact’s platform (if any)

artifact${PlatformReplaced}PlatformReplaced

the artifact’s replaced platform (if any)

artifact${PlatformReplaced}Os

the os component of the artifact’s platform (if any)

artifact${PlatformReplaced}Arch

the arch component of the artifact’s platform (if any)

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

artifact${PlatformReplaced}DownloadUrl

the URL required to download the artifact

artifact${PlatformReplaced}Download${Type}Url

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

artifact${PlatformReplaced}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, artifact{{Platform}}, and artifact{{PlatformReplaced}} 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-aarch_64
[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-aarch_64"
{
  "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-aarch_64"
        }
      ],
    }
  }
}
<jreleaser>
  <checksum>
    <algorithms>
      <algorithm>MD5</algorithm>
      <algorithm>SHA-256</algorithm>
    </algorithms>
  </checksum>
  <distributions>
    <app>
      <artifacts>
        <artifact>
          <path>path/to/{{distributionName}}-{{projectVersion}}.zip</path>
          <extraProperties>
            <main>true</main>
          </extraProperties>
        </artifact>
        <artifact>
          <path>path/to/{{distributionName}}-{{projectVersion}}-mac.zip</path>
          <platform>osx-aarch_64</platform>
        </artifact>
      </artifacts>
    </app>
  </distributions>
</jreleaser>
jreleaser {
  checksum {
    algorithm('MD5')
    algorithm('SHA-256')
  }
  distributions {
    app {
      artifact {
        path = "path/to/{{distributionName}}-{{projectVersion}}.zip"
        extraProperties.put("main", true)
      }
      artifact {
        path = "path/to/{{distributionName}}-{{projectVersion}}-mac.zip"
        platform = 'osx-aarch_64'
      }
    }
  }
}

The following names will be calculated:

1st artifact

  • artifactUrl

  • artifactChecksumMd5

  • artifactChecksumSha256

  • artifactFile: {{distributionName}}-{{projectVersion}}.zip

  • artifactFileName: {{distributionName}}-{{projectVersion}}

  • artifactFileExtension: .zip

  • artifactFileFormat: zip

  • artifactRootEntryName: {{distributionName}}-{{projectVersion}}

  • artifactName: {{distributionName}}

  • artifactVersion: {{projectVersion}}

  • artifactSize

  • artifactMain: true

  • distributionUrl

  • distributionSize

  • distributionChecksumMd5

  • distributionChecksumSha256

  • distributionArtifactFile: {{distributionName}}-{{projectVersion}}.zip

  • distributionArtifactFileName: {{distributionName}}-{{projectVersion}}

  • distributionArtifactFileExtension: .zip

  • distributionArtifactFileFormat: zip

  • distributionArtifactName: {{distributionName}}

  • distributionArtifactVersion: {{projectVersion}}

  • distributionArtifactSize

Platform specific artifact

  • artifactOsxAarch64Url

  • artifactOsxAarch64ChecksumMd5

  • artifactOsxAarch64ChecksumSha256

  • artifactOsxAarch64File: {{distributionName}}-{{projectVersion}}.zip

  • artifactOsxAarch64FileName: {{distributionName}}-{{projectVersion}}

  • artifactOsxAarch64FileExtension: .zip

  • artifactOsxAarch64FileFormat: zip

  • artifactOsxAarch64Name: {{distributionName}}

  • artifactOsxAarch64Version: {{projectVersion}}

  • artifactOsxAarch64Platform: osx-aarch_64

  • artifactOsxAarch64Os: osx

  • artifactOsxAarch64Arch: aarch_64

  • artifactOsxAarch64Size

Artifactory

The following names are related to the Artifactory uploader

Key Description

uploaderName

resolves to the named Artifactory instance

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

AppImage

The following names are related to AppImage.

Key Description

appImageRepositoryOwner

the owner of the Git repository

appImageRepositoryName

the name of the Git repository

appImageComponentId

the component id

appImageCategories

the list of categories

appImageDeveloperName

the developer name

appImageRequiresTerminal

boolean indicating if the project requires terminal access

appImageReleases

list of releases

appImageUrls

list of links

appImageScreenshots

list of screenshots

appImageIcons

list of icons

appImageDistributionUrl

the URL required to download the artifact

appImageDistributionArtifactFile

the name of the artifact file

appImageDistributionArtifactFileName

the name of the artifact file without extension

appImageDistributionArtifactRootEntryName

the name of the artifact’s root entry

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

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

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

Asdf

The following names are related to Asdf.

Key Description

asdfDistributionUrl

the URL required to download the artifact

asdfDistributionArtifactFile

the name of the artifact file

asdfDistributionArtifactFileName

the name of the artifact file without extension

asdfDistributionArtifactRootEntryName

the name of the artifact’s root entry

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

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

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

Bluesky

The following names are related to Bluesky.

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

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

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

Brew

The following names are related to Homebrew.

Key Description

brewRepositoryOwner

owner of the tap repository URL, defaults to #{release.owner}

brewRepositoryName

name of the tap repository URL, defaults to homebrew-tap

brewRepositoryAlias

short name of the tap repository URL, defaults to tap

brewRepositoryUrl

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

brewRepositoryCloneUrl

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

brewDownloadStrategy

custom download strategy

brewRequireRelative

a list of required files, added as require_relative statements

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

chocolateyPackageName

the name of the Chocolatey package. Defaults to #{distribution.name}

chocolateyUsername

the name of the Chocolatey username

chocolateyTitle

the title to use in the spec

chocolateyIconUrl

the icon URL

chocolateyRepositoryUrl

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

chocolateyRepositoryCloneUrl

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

chocolateyPackageSourceUrl

URL where the spec may be found

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

Cyclonedx

The following names are related to CycloneDX.

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

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

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

Docker

The following names are related to Docker.

Key Description

dockerBaseImage

the base Docker image

dockerLabels

a list of formatted labels

dockerSpecName

the name of the current Docker spec

dockerPreCommands

a list of commands to be invoked before copying sources

dockerPostCommands

a list of commands to be invoked after copying sources

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

The following names are related to 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')
    }
  }
}

Discourse

The following names are related to Discourse.

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

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

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

GitHub Discussions

The following names are related to 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

The following names are related to 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')
    }
  }
}

Flatpak

The following names are related to Flatpak.

Key Description

flatpakRepositoryOwner

the owner of the Git repository

flatpakRepositoryName

the name of the Git repository

flatpakComponentId

the component id

flatpakCategories

the list of categories

flatpakCategoriesByComma

the list of categories separated by comma

flatpakCategoriesBySemicolon

the list of categories separated by semicolon

flatpakDeveloperName

the developer name

flatpakReleases

list of releases

flatpakUrls

list of links

flatpakScreenshots

list of screenshots

flatpakIcons

list of icons

flatpakDirectories

list of directories to be created

flatpakBinaries

list of binaries to be installed

flatpakFiles

list of files to be installed

flatpakHasSdkExtensions

if there are any SDK extensions

flatpakSdkExtensions

list of SDK extensions

flatpakHasFinishArgs

if there are any finish args

flatpakFinishArgs

list of finish args

flatpakRuntime

the flatpak runtime to use

flatpakRuntimeVersion

version of the flatpak runtime

flatpakSdk

flatpak sdk

flatpakIncludeOpenJdk

boolean indicating if OpenJDK shiuld be automaticall installed

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

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

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

GoogleChat

The following names are related to 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')
    }
  }
}

Linkedin

The following names are related to Linkedin.

Key Description

linkedinOwner

the URN identifying the actor that can post a share

linkedinSubject

the post subject

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

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

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

Http

The following names are related to the Http uploader.

Key Description

uploaderName

resolves to the named Http instance

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

  • TOML

  • JSON

  • Maven

  • Gradle

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

jbangRepositoryUrl

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

jbangRepositoryCloneUrl

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

jbangAliasName

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

jbangScriptName

the name of the jbang script file, {{distributionExecutableName}} or {{distributionExecutableName}}_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')
    }
  }
}

Jib

The following names are related to Jib.

Key Description

jibBaseImage

the base Jib image

jibSpecName

the name of the current Jib spec

jibCreationTime

the image’s creation time

jibUser

the image’s user

jibFormat

the image’s format

jibWorkingDirectory

the image’s working directory

jibHasVolumes

if there are any volumes defined

jibVolumes

set of volumes

jibHasExposedPorts

if there are any exposed ports

jibExposedPorts

set of exposed ports

jibHasEnvironment

if there are any environment variables defined

jibEnvironment

set of environment variables

jibLabels

a list of formatted labels

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

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

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

Macports

The following names are related to Macports.

Key Description

macportsPackageName

the name of the Macports package. Defaults to #{distribution.name}

macportsRepositoryUrl

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

macportsRepositoryCloneUrl

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

macportsDistname

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

The following names are related to 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

The following names are related to 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

The following names are related to 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')
    }
  }
}

OpenCollective

The following names are related to reference:announce/openCollective.adoc.

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

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

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

S3

The following names are related to the AWS S3 uploader.

Key Description

uploaderName

resolves to the named S3 instance

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

scoopPackageName

the name of the Scoop package. Defaults to #{distribution.executable.name}

scoopRepositoryUrl

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

scoopRepositoryCloneUrl

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

scoopAutoupdateExtractDir

name of the extraction dir used by autoupdate

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

The following names are related to both Sdkman announcer and Sdkman packager.

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

The following names are related to 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')
    }
  }
}

Smtp

The following names are related to Smtp.

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

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

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

Snap

The following names are related to Snap.

Key Description

snapPackageName

the name of the Snap package. Defaults to #{distribution.name}

snapRepositoryUrl

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

snapRepositoryCloneUrl

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

snapHasArchitectures

a boolean, when the snap defines architectures

snapArchitectures

a list of architectures

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

An Architecture defines the following fields

Key Description

buildOn

a list of archs for build-on

runOn

a list of archs for run-on

hasRunOn

a boolean, when the architecture defines runOn

IgnoreError

a boolean, when the architecture ignores build errors

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

specPackageName

the name of the Spec. Defaults to #{distribution.name}

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

specBinaries

List of binary files to be installed

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

Syft

The following names are related to Syft.

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

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

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

Teams

The following names are related to 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

The following names are related to 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

The following names are related to 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

The following names are related to 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')
      }
    }
  }
}

Winget

The following names are related to Winget.

Key Description

wingetPackageIdentifier

wingetPackageName

wingetPackageVersion

wingetPackageUrl

wingetPackageLocale

wingetPackagePublisher

wingetPublisherUrl

wingetPublisherSupportUrl

wingetDefaultLocale

wingetAuthor

wingetMoniker

wingetMinimumOsVersion

wingetProductCode

wingetHasTags

if there are any tags

wingetTags

wingetManifestType

wingetInstallerType

wingetScope

wingetInstallModes

wingetUpgradeBehavior

wingetReleaseDate

wingetInstallerArchitecture

wingetInstallers

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

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

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

Zulip

The following names are related to 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')
    }
  }
}