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 |
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 |
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 |
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 |
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 |
f_underscores |
transforms |
f_upper |
invokes |
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
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
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
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 |
osPlatformReplaced |
|
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 |
previousTagName |
the tag to compare the release tag to, defaults to the previous tag |
releaseName |
the release name, defaults to |
milestoneName |
the milestone name/title, defaults to |
repoCanonicalName |
the canonical name of the repository, |
repoUrl |
the repository URL, |
repoCloneUrl |
the repository clone URL, |
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
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
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
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
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
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
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
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
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 |
brewRepositoryName |
name of the tap repository URL, defaults to |
brewRepositoryAlias |
short name of the tap repository URL, defaults to |
brewRepositoryUrl |
the tap repository URL, |
brewRepositoryCloneUrl |
the tap repository clone URL, |
brewFormulaName |
the formula name. Defaults to |
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 |
brewCaskName |
the cask name |
brewCaskDisplayName |
value for the cask’s |
brewCaskHasPkg |
if the cask contains a |
brewCaskPkgName |
value for the cask’s |
brewCaskHasApp |
if the cask contains a |
brewCaskAppName |
value for the cask’s |
brewCaskHasUninstall |
if the cask defines a |
brewCaskUninstall |
the |
brewCaskHasZap |
if the cask defines a |
brewCaskZap |
the |
brewCaskHasAppcast |
if the cask defines an |
brewCaskAppcast |
the |
brewCaskHasBinary |
if the cask contains a |
Additionally, every key/value from brew.extraProperties
is mapped with brew
as key prefix and the capitalized
key, such that
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 |
chocolateyUsername |
the name of the Chocolatey username |
chocolateyTitle |
the title to use in the spec |
chocolateyIconUrl |
the icon URL |
chocolateyRepositoryUrl |
the bucket repository URL, |
chocolateyRepositoryCloneUrl |
the bucket clone repository URL, |
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
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
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
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
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
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
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
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
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
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')
}
}
}
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
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
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')
}
}
}
}
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, |
jbangRepositoryCloneUrl |
the catalog repository clone URL, |
jbangAliasName |
the name of the jbang alias, |
jbangScriptName |
the name of the jbang script file, |
jbangDistributionGA |
calculated Maven coordinates for https://jitpack.io
|
Additionally, every key/value from jbang.extraProperties
is mapped with jbang
as key prefix and the capitalized
key, such that
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
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 |
macportsRepositoryUrl |
the repository URL, |
macportsRepositoryCloneUrl |
the repository clone URL, |
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
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')
}
}
}
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
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
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
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
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
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 |
scoopRepositoryUrl |
the bucket repository URL, |
scoopRepositoryCloneUrl |
the bucket repository clone URL, |
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
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
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
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
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 |
snapRepositoryUrl |
the snap repository URL, |
snapRepositoryCloneUrl |
the snap repository clone URL, |
snapBase |
the snap base |
snapGrade |
the snap grade |
snapConfinement |
the snap confinement |
snapHasPlugs |
a boolean, when there snap defines plugs |
snapPlugs |
a list of |
snapHasSlots |
a boolean, when the snap defines slots |
snapSlots |
a list of |
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
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 |
specRepositoryRepoUrl |
the repository URL, |
specRepositoryRepoCloneUrl |
the repository clone URL, |
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
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
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
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
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')
}
}
}
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
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
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
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
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')
}
}
}