PkgTemplates

https://juliaci.github.io/PkgTemplates.jl/
Admin
PkgTemplates creates new Julia packages in an easy, repeatable, and customizable way.
Tokens:17,588
Snippets:218
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install PkgTemplates using Pkg.add

Source: https://juliaci.github.io/PkgTemplates.jl

Install PkgTemplates programmatically using Pkg.add.

```julia
using Pkg; Pkg.add("PkgTemplates")
```

--------------------------------

### Install PkgTemplates using Pkg REPL

Source: https://juliaci.github.io/PkgTemplates.jl

Install PkgTemplates using the Julia package manager Pkg in the REPL.

```julia
pkg> add PkgTemplates  # Press ']' to enter the Pkg REPL mode.
```

--------------------------------

### Setup Package Benchmarks

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Sets up a PkgBenchmark.jl benchmark suite. Ensure benchmark reproducibility by creating a dedicated environment in the `benchmark` subfolder.

```julia
PkgBenchmark(; file="~/work/PkgTemplates.jl/PkgTemplates.jl/templates/benchmark/benchmarks.jlt")
```

--------------------------------

### Install PkgTemplates

Source: https://juliaci.github.io/PkgTemplates.jl/stable

Install PkgTemplates using the Julia package manager Pkg. This can be done in the Pkg REPL mode or directly within a Julia session.

```julia
pkg> add PkgTemplates  # Press ']' to enter the Pkg REPL mode.
```

```julia
julia> using Pkg; Pkg.add("PkgTemplates")
```

--------------------------------

### Rendered Output Example

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

The expected output after rendering the example Mustache template with the provided view data.

```text
Hello, Chris.

It's sunny outside.

I have the following things:
- Here's a thing: a
- Here's a thing: b
- Here's a thing: c

- John is happy
- Jane is sad
```

--------------------------------

### Install and Run Specific Julia Version

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Install and run Julia 1.7.2 using juliaup for local testing of reference tests. This ensures crucial correctness checks are performed.

```bash
juliaup add 1.7.2
julia +1.7.2
```

--------------------------------

### Mustache Template Example

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

An example of a Mustache template file demonstrating various syntax for variable substitution, conditional rendering, and iteration. Use triple curly braces \"{{{}}}\" to disable HTML escaping.

```mustache
Hello, {{{name}}}.

{{#weather}}
It's {{{weather}}} outside.
{{/weather}}
{{^weather}}
I don't know what the weather outside is.
{{/weather}}

{{#has_things}}
I have the following things:
{{/has_things}}
{{#things}}
- Here's a thing: {{{.}}}
{{/things}}

{{#people}}
- {{{name}}} is {{{mood}}}
{{/people}}
```

--------------------------------

### Customized Package Template

Source: https://juliaci.github.io/PkgTemplates.jl/stable

Create a customized Template with specific options and plugins. This example includes Git, GitHubActions, Codecov, and Documenter plugins.

```julia
using PkgTemplates
tpl = Template(;
    dir="~/code",
    plugins=[
        Git(; manifest=true, ssh=true),
        GitHubActions(; x86=true),
        Codecov(),
        Documenter{GitHubActions}(),
    ],
)
```

--------------------------------

### CITATION.bib Template Example

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

An example of a CITATION.bib template file used by the Citation plugin, demonstrating custom delimiters and placeholders for package information.

```bibtex
@misc{<<&PKG>>.jl,
	author  = {<<&AUTHORS>>},
	title   = {<<&PKG>>.jl},
	url     = {<<&URL>>},
	version = {v0.1.0},
	year    = {<<&YEAR>>},
	month   = {<<&MONTH>>}
}
```

--------------------------------

### Mustache View Data Example

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

An example of a Julia struct and dictionary representing the data (view) to be used with a Mustache template. Supports nested structures and lists.

```julia
struct Person; name::String; mood::String; end
things = ["a", "b", "c"]
view = Dict(
    "name" => "Chris",
    "weather" => "sunny",
    "has_things" => !isempty(things),
    "things" => things,
    "people" => [Person("John", "happy"), Person("Jane", "sad")],
)
```

--------------------------------

### Get Package Name

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Return the package name from a directory path. It excludes any `.jl` suffix. For example, `foo/bar/Whee.jl` and `foo/bar/Whee` both return `Whee`.

```julia
pkg_name(pkg_dir::AbstractString)
```

--------------------------------

### Define a Documenter Plugin

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Defines a `Documenter` plugin struct with default file paths for documentation generation. This plugin integrates with PkgTemplates to automate documentation setup.

```julia
@plugin struct Documenter <: Plugin
    make_jl::String = default_file("docs", "make.jlt")
    index_md::String = default_file("docs", "src", "index.md")
end

gitignore(::Documenter) = ["/docs/build/"]

badges(::Documenter) = [
    Badge(
        "Stable",
        "https://img.shields.io/badge/docs-stable-blue.svg",
        "https://{{{USER}}}.github.io/{{{PKG}}}.jl/stable",
    ),
    Badge(
        "Dev",
        "https://img.shields.io/badge/docs-dev-blue.svg",
        "https://{{{USER}}}.github.io/{{{PKG}}}.jl/dev",
    ),
]

view(p::Documenter, t::Template, pkg::AbstractString) = Dict(
    "AUTHORS" => join(t.authors, ", "),
    "PKG" => pkg,
    "REPO" => "$(t.host)/$(t.user)/$pkg.jl",
    "USER" => t.user,
)

function hook(p::Documenter, t::Template, pkg_dir::AbstractString)
    pkg = pkg_name(pkg_dir)
    docs_dir = joinpath(pkg_dir, "docs")

    make = render_file(p.make_jl, combined_view(p, t, pkg), tags(p))
    gen_file(joinpath(docs_dir, "make.jl"), make)

    index = render_file(p.index_md, combined_view(p, t, pkg), tags(p))
    gen_file(joinpath(docs_dir, "src", "index.md"), index)

    # What this function does is not relevant here.
    create_documentation_project()
end
```

--------------------------------

### Git

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Initializes a Git repository and creates a .gitignore file.

```APIDOC
## Git

### Description
Creates a Git repository and a `.gitignore` file.

### Constructor
```julia
Git(; ignore=String[], name=nothing, email=nothing, branch=LibGit2.getconfig("init.defaultBranch", "main"), ssh=false, jl=true, manifest=false, gpgsign=false)
```

### Keyword Arguments
* `ignore::Vector{<:AbstractString}` - Patterns to add to the `.gitignore`. See also: `gitignore`.
* `name::AbstractString` - Your real name, if you have not set `user.name` with Git.
* `email::AbstractString` - Your email address, if you have not set `user.email` with Git.
* `branch::AbstractString` - The desired name of the repository's default branch.
* `ssh::Bool` - Whether or not to use SSH for the remote. If left unset, HTTPS is used.
* `jl::Bool` - Whether or not to add a `.jl` suffix to the remote URL.
* `manifest::Bool` - Whether or not to commit `Manifest.toml`.
* `gpgsign::Bool` - Whether or not to sign commits with your GPG key. This option requires that the Git CLI is installed, and for you to have a GPG key associated with your committer identity.
```

--------------------------------

### Create Project.toml with Version

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Use this to create a Project.toml file for a new package. Specify the initial version using the `version` keyword argument.

```julia
ProjectFile(; version=v"1.0.0-DEV")
```

--------------------------------

### Readme

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Creates a README.md file with badges for other plugins.

```APIDOC
## Readme

### Description
Creates a `README` file that contains badges for other included plugins.

### Constructor
```julia
Readme(; file="~/work/PkgTemplates.jl/PkgTemplates.jl/templates/README.md", destination="README.md", inline_badges=false)
```

### Keyword Arguments
* `file::AbstractString` - Template file for the `README`.
* `destination::AbstractString` - File destination, relative to the repository root. For example, values of `"README"` or `"README.rst"` might be desired.
* `inline_badges::Bool` - Whether or not to put the badges on the same line as the package name.
* `badge_order::Vector{typeof(Plugin)}` - Plugins in the order their badges should appear.
* `badge_off::Vector{typeof(Plugin)}` - Plugins which should not have their badges added.
```

--------------------------------

### Initialize Git Repository

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Initializes a Git repository and creates a .gitignore file. Configure user details, default branch, and commit options like manifest and GPG signing.

```julia
Git(; ignore=String[], name=nothing, email=nothing, branch=LibGit2.getconfig("init.defaultBranch", "main"), ssh=false, jl=true, manifest=false, gpgsign=false)
```

--------------------------------

### Create and Use a Package Template

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Instantiate a default template and use it to generate a new package. The default template includes common plugins like ProjectFile, SrcDir, Tests, Readme, License, Git, Dependabot, TagBot, and GitHubActions.

```julia
using PkgTemplates
t = Template()
t("MyPkg")
```

--------------------------------

### Get Template Delimiters

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Return the delimiters used for text templating. By default, the tags are `{{"{{ "}}` and `{{"}}" }}`.

```julia
tags(::Plugin) -> Tuple{String, String}
```

--------------------------------

### ProjectFile

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Creates a Project.toml file for the package.

```APIDOC
## ProjectFile

### Description
Creates a `Project.toml` file.

### Constructor
```julia
ProjectFile(; version=v"1.0.0-DEV")
```

### Keyword Arguments
* `version::VersionNumber` - The initial version of created packages.
```

--------------------------------

### Define Template Loading Function in startup.jl

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Add this function to your `startup.jl` file to load a template on demand without impacting startup time. It uses `@eval` to ensure `PkgTemplates` is available.

```julia
function template()
    @eval begin
        using PkgTemplates
        Template(; #= ... =#)
    end
end
```

--------------------------------

### Generate README with Badges

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Creates a README.md file, optionally including badges from other plugins. Configure the template file, destination, and badge display.

```julia
Readme(; file="~/work/PkgTemplates.jl/PkgTemplates.jl/templates/README.md", destination="README.md", inline_badges=false)
```

--------------------------------

### Extending Plugin View with user_view

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Example of implementing the `user_view` function to add custom data, like the current date, to a plugin's template rendering context. This function's values override default `view` values when keys conflict.

```julia
user_view(::Readme, ::Template, ::AbstractString) = Dict("TODAY" => today())
```

--------------------------------

### SrcDir

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Creates a module entrypoint file for the src directory.

```APIDOC
## SrcDir

### Description
Creates a module entrypoint.

### Constructor
```julia
SrcDir(; file="~/work/PkgTemplates.jl/PkgTemplates.jl/templates/src/module.jlt")
```

### Keyword Arguments
* `file::AbstractString` - Template file for `src/<module>.jl`.
```

--------------------------------

### Set up Coveralls for CI

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Configure code coverage submission to Coveralls. You can specify a template file for `.coveralls.yml` or set it to `nothing` to create no file.

```julia
Coveralls(; file=nothing)
```

--------------------------------

### Create License File

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Generates a license file for your package. Specify the license name or provide a path to a custom license file.

```julia
License(; name="MIT", path=nothing, destination="LICENSE")
```

--------------------------------

### Manual Package Creation

Source: https://juliaci.github.io/PkgTemplates.jl/stable

Manually create a Template object. The no-keywords constructor requires pre-existing Git configuration for user.name, user.email, and github.user.

```julia
using PkgTemplates
tpl = Template()
```

--------------------------------

### Tests

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Sets up testing infrastructure for packages.

```APIDOC
## Tests

### Description
Sets up testing for packages.

### Constructor
```julia
Tests(; file="~/work/PkgTemplates.jl/PkgTemplates.jl/templates/test/runtests.jlt", project=false, aqua=false, aqua_kwargs=NamedTuple(), jet=false)
```

### Keyword Arguments
* `file::AbstractString` - Template file for `runtests.jl`.
* `project::Bool` - Whether or not to create a new project for tests (`test/Project.toml`). See the Pkg docs for more details.
* `aqua::Bool` - Controls whether or not to add quality tests with Aqua.jl.
* `aqua_kwargs::NamedTuple` - Which keyword arguments to supply to Aqua tests (many people use `ambiguities=false` for example)
* `jet::Bool` - Controls whether or not to add a linting test with JET.jl (works best on type-stable code)
```

--------------------------------

### Git Plugin Implementation

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Implements a Git plugin for PkgTemplates, handling repository initialization, initial commit, .gitignore generation, and final commit. Requires global Git configuration.

```julia
struct Git <: Plugin end

priority(::Git, ::typeof(posthook)) = 5

function validate(::Git, ::Template)
    foreach(("user.name", "user.email")) do k
        if isempty(LibGit2.getconfig(k, ""))
            throw(ArgumentError("Git: Global Git config is missing required value '$k'"))
        end
    end
end

function prehook(::Git, t::Template, pkg_dir::AbstractString)
    LibGit2.with(LibGit2.init(pkg_dir)) do repo
        LibGit2.commit(repo, "Initial commit")
        pkg = pkg_name(pkg_dir)
        url = "https://$(t.host)/$(t.user)/$pkg.jl"
        close(GitRemote(repo, "origin", url))
    end
end

function hook(::Git, t::Template, pkg_dir::AbstractString)
    ignore = mapreduce(gitignore, append!, t.plugins)
    unique!(sort!(ignore))
    gen_file(joinpath(pkg_dir, ".gitignore"), join(ignore, "\n"))
end

function posthook(::Git, ::Template, pkg_dir::AbstractString)
    LibGit2.with(GitRepo(pkg_dir)) do repo
        LibGit2.add!(repo, ".")
        LibGit2.commit(repo, "Files generated by PkgTemplates")
    end
end
```

--------------------------------

### Implement Plugin View

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Implement this function to provide data for text templating within plugins. `pkg` is the name of the package being generated. By default, an empty Dict is returned.

```julia
view(::Plugin, ::Template, pkg::AbstractString) -> Dict{String, Any}
```

--------------------------------

### Configure Documenter.jl Plugin

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Sets up documentation generation via Documenter.jl. Documentation deployment depends on the type parameter T, which can be a supported CI plugin or Nothing for local builds only.

```julia
Documenter{
    make_jl="~/work/PkgTemplates.jl/PkgTemplates.jl/templates/docs/make.jlt",
    index_md="~/work/PkgTemplates.jl/PkgTemplates.jl/templates/docs/src/index.md",
    assets=String[],
    logo=Logo(),
    canonical_url=make_canonical(T),
    devbranch=nothing,
    edit_link=:devbranch,
    makedocs_kwargs=Dict{Symbol,Any}(),
}
```

--------------------------------

### Input Tips for Type Conversion

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Function signature to provide user tips for input formatting during interactive mode.

```julia
input_tips(::Type{T}) -> Vector{String}
```

--------------------------------

### PkgTemplates.render_file

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Renders a template file using the provided view data and optional custom delimiters.

```APIDOC
## PkgTemplates.render_file

### Description
Render a template file with the data in `view`. `tags` should be a tuple of two strings, which are the opening and closing delimiters, or `nothing` to use the default delimiters.

### Function Signature
```julia
render_file(file::AbstractString, view::Dict{<:AbstractString}, tags=nothing) -> String
```
```

--------------------------------

### Create src/module.jl Entrypoint

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Generates the main module file for your package's source directory. Customize the template file path using the `file` argument.

```julia
SrcDir(; file="~/work/PkgTemplates.jl/PkgTemplates.jl/templates/src/module.jlt")
```

--------------------------------

### Set up Codecov for CI

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Configure code coverage submission to Codecov. You can specify a template file for `.codecov.yml` or set it to `nothing` to create no file.

```julia
Codecov(; file=nothing)
```

--------------------------------

### Configure Documentation Logo

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Sets up logo information for documentation, allowing for separate logos for light and dark themes.

```julia
Logo(; light=nothing, dark=nothing)
```

--------------------------------

### Configure Drone CI Integration

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Integrate your packages with Drone CI. Configure the template file, and specify whether to run builds on AMD64, ARM (32-bit), and ARM64. Extra Julia versions can also be specified. Nightly Julia is not supported.

```julia
DroneCI(;
    file="~/work/PkgTemplates.jl/PkgTemplates.jl/templates/drone.star",
    amd64=true,
    arm=false,
    arm64=false,
    extra_versions=["1.10", "1.12"],
)
```

--------------------------------

### Plugin Prehook Stage

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

The first stage of the package generation process. `pkg_dir` is an empty directory at this point. Plugins can create files here, but `pkg_dir` will only remain empty until the first file is created.

```julia
prehook(::Plugin, ::Template, pkg_dir::AbstractString)
```

--------------------------------

### Define a Custom Plugin with @plugin Macro

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Demonstrates how to define a custom plugin using the `@plugin` macro, which simplifies the creation of plugin subtypes with keyword constructors and default values.

```julia
@plugin struct MyPlugin <: Plugin
    x::String = "hello!"
    y::Union{Int, Nothing} = nothing
end
```

--------------------------------

### License

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Creates a license file for the package.

```APIDOC
## License

### Description
Creates a license file.

### Constructor
```julia
License(; name="MIT", path=nothing, destination="LICENSE")
```

### Keyword Arguments
* `name::AbstractString` - Name of a license supported by PkgTemplates. Available licenses can be seen here.
* `path::Union{AbstractString, Nothing}` - Path to a custom license file. This keyword takes priority over `name`.
* `destination::AbstractString` - File destination, relative to the repository root. For example, `"LICENSE.md"` might be desired.
```

--------------------------------

### Manually Implement Default Values for Plugin Fields

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Shows how to manually implement default values for plugin fields using `PkgTemplates.defaultkw` when the `@plugin` macro's automatic handling is not suitable or desired.

```julia
using PkgTemplates: PkgTemplates, Plugin
struct MyPlugin <: Plugin
    x::String
end
PkgTemplates.defaultkw(::Type{MyPlugin}, ::Val{:x}) = "my default"
```

--------------------------------

### PkgTemplates.gen_file

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Creates a new file with the specified name and content, ensuring it ends with a newline.

```APIDOC
## PkgTemplates.gen_file

### Description
Create a new file containing some given text. Trailing whitespace is removed, and the file will end with a newline.

### Function Signature
```julia
gen_file(file::AbstractString, text::AbstractString)
```
```

--------------------------------

### Generate a Package Interactively

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Use the `generate` function for interactive package creation. If a package name is provided, it acts as a shortcut for `Template(; interactive=true)(pkg)`. Otherwise, the user will be prompted for a package name.

```julia
julia> t = Template();

julia> t("PkgName")
```

```julia
generate([pkg::AbstractString]) -> Template
```

--------------------------------

### PkgTemplates.render_text

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Renders a given string with the provided view data and optional custom delimiters.

```APIDOC
## PkgTemplates.render_text

### Description
Render some text with the data in `view`. `tags` should be a tuple of two strings, which are the opening and closing delimiters, or `nothing` to use the default delimiters.

### Function Signature
```julia
render_text(text::AbstractString, view::Dict{<:AbstractString}, tags=nothing) -> String
```
```

--------------------------------

### Configure Package Testing

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Sets up the testing infrastructure for your package. Control the inclusion of Aqua.jl and JET.jl, and whether to create a separate test project.

```julia
Tests(; file="~/work/PkgTemplates.jl/PkgTemplates.jl/templates/test/runtests.jlt", project=false, aqua=false, aqua_kwargs=NamedTuple(), jet=false)
```

--------------------------------

### PkgTemplates.view

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Retrieves the view dictionary used to fill placeholders in badges and rendered files for a given plugin and package.

```APIDOC
## PkgTemplates.view

### Description
Return the view to be passed to the text templating engine for this plugin. `pkg` is the name of the package being generated.
For `FilePlugin`s, this is used for both the plugin badges (see `badges`) and the template file (see `source`). For other `Plugin`s, it is used only for badges, but you can always call it yourself as part of your `hook` implementation.
By default, an empty `Dict` is returned.

### Function Signature
```julia
view(::Plugin, ::Template, pkg::AbstractString) -> Dict{String, Any}
```
```

--------------------------------

### Create Citation File

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Creates a `CITATION.bib` file for citing package repositories. The `file` argument specifies the template file, and `readme` controls whether to include a citation section in the README.

```julia
Citation(; file="~/work/PkgTemplates.jl/PkgTemplates.jl/templates/CITATION.bib", readme=false)
```

--------------------------------

### Migrating Interactive Mode

Source: https://juliaci.github.io/PkgTemplates.jl/stable/migrating

Interactive template generation is now configured via the `interactive` keyword argument in `Template`.

```julia
Template(; interactive=true)
```

```julia
Template(; interactive=true)(pkg)
```

--------------------------------

### Configure Code Formatter

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Creates a `.JuliaFormatter.toml` file for automatic code formatting. The `file` argument specifies the template, and `style` can be one of `("sciml", "blue", "yas")` or a custom style.

```julia
Formatter(;
    file="~/work/PkgTemplates.jl/PkgTemplates.jl/templates/.JuliaFormatter.toml",
    style="nostyle"
)
```

--------------------------------

### Register Package Action

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Adds a GitHub Actions workflow for registering a package with the General registry via workflow dispatch. The `file` argument specifies the template, `destination` the file path relative to `.github/workflows`, and `prompt` the text for workflow dispatch.

```julia
RegisterAction(;
    file="~/work/PkgTemplates.jl/PkgTemplates.jl/templates/github/workflows/Register.yml",
    destination="Register.yml",
    prompt="Version to register or component to bump",
)
```

--------------------------------

### Citation Plugin Implementation

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Implements a Citation plugin for PkgTemplates, generating a CITATION.bib file. It defines the source and destination of the template file, custom tags, and the data view for populating the template.

```julia
@plugin struct Citation <: FilePlugin
    file::String = default_file("CITATION.bib")
end

source(p::Citation) = p.file
destination(::Citation) = "CITATION.bib"

tags(::Citation) = "<<", ">>"

view(::Citation, t::Template, pkg::AbstractString) = Dict(
    "AUTHORS" => join(t.authors, ", "),
    "MONTH" => month(today()),
    "PKG" => pkg,
    "URL" => "https://$(t.host)/$(t.user)/$pkg.jl",
    "YEAR" => year(today()),
)
```

--------------------------------

### Template + Package Creation Pipeline

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

The package creation process involves template validation and sequential execution of plugin hooks (prehook, hook, posthook).

```APIDOC
## Template + Package Creation Pipeline
The `Template` constructor basically does this:
```
- extract values from keyword arguments
- create a Template from the values
- for each plugin:
  - validate plugin against the template
```

The plugin validation step uses the `validate` function. It lets us catch mistakes before we try to generate packages.

```

```APIDOC
## PkgTemplates.validate — Function

```
validate(::Plugin, ::Template)
```

Perform any required validation for a `Plugin`. It is preferred to do validation here instead of in `prehook`, because this function is called at `Template` construction time, whereas the prehook is only run at package generation time.

```

```APIDOC
The package generation process looks like this:
```
- create empty directory for the package
- for each plugin, ordered by priority:
  - run plugin prehook
- for each plugin, ordered by priority:
  - run plugin hook
- for each plugin, ordered by priority:
  - run plugin posthook
```

As you can tell, plugins play a central role in setting up a package. The three main entrypoints for plugins to do work are the `prehook`, the `hook`, and the `posthook`. As the names might imply, they basically mean "before the main stage", "the main stage", and "after the main stage", respectively. Each stage is basically identical, since the functions take the exact same arguments. However, the multiple stages allow us to depend on artifacts of the previous stages. For example, the `Git` plugin uses `posthook` to commit all generated files, but it wouldn't make sense to do that before the files are generated. But what about dependencies within the same stage? In this case, we have `priority` to define which plugins go when. The `Git` plugin also uses this function to lower its posthook's priority, so that even if other plugins generate files in their posthooks, they still get committed (provided that those plugins didn't set an even lower priority).

```

--------------------------------

### Deserialize Template from a Binary File

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Load a template from a binary file using `deserialize`. This method is efficient but has potential version compatibility issues.

```julia
using Serialization
const t = open(deserialize, "template.bin")
```

--------------------------------

### Configure AppVeyor CI Integration

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Use this to integrate your packages with AppVeyor. Specify the template file, whether to run on 32-bit systems, enable coverage, and list extra Julia versions.

```julia
AppVeyor(;
    file="~/work/PkgTemplates.jl/PkgTemplates.jl/templates/appveyor.yml",
    x86=false,
    coverage=true,
    extra_versions=["1.10", "1.12", "nightly"],
)
```

--------------------------------

### Coveralls Plugin

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Sets up code coverage submission to Coveralls.

```APIDOC
## PkgTemplates.Coveralls

### Description
Sets up code coverage submission from CI to Coveralls.

### Constructor
```julia
Coveralls(; file=nothing)
```

### Keyword Arguments
* `file::Union{AbstractString, Nothing}` : Template file for `.coveralls.yml`, or `nothing` to create no file.
```

--------------------------------

### Configure GitHub Actions CI

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Integrates your package with GitHub Actions for continuous integration. Specify which operating systems and architectures to test on, and whether to include coverage.

```julia
GitHubActions(; file="~/work/PkgTemplates.jl/PkgTemplates.jl/templates/github/workflows/CI.yml", destination="CI.yml", linux=true, osx=false, windows=false, x64=true, x86=false, coverage=true, extra_versions=["1.10", "1.12", "pre"])
```

--------------------------------

### Add BlueStyle Badge

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Adds a BlueStyle badge to the README file.

```julia
BlueStyleBadge()
```

--------------------------------

### Implement gitignore for a Plugin

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Provides a method for the `gitignore` function to specify patterns that should be added to the `.gitignore` file, typically used to exclude build artifacts.

```julia
gitignore(::Plugin) -> Vector{String}
```

--------------------------------

### Develop Package

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Adds generated packages to the current environment by `dev`ing them. Refer to the Pkg documentation for more details.

```julia
Develop()
```

--------------------------------

### Load Template from a Julia File

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Include a previously saved Julia file to load the template. This is a straightforward way to reuse a template configuration.

```julia
const t = include("template.jl")
```

--------------------------------

### Add PkgEval Badge

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Adds a PkgEval badge to the README file.

```julia
PkgEvalBadge()
```

--------------------------------

### Render Template File

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Render a template file with provided data. `tags` should be a tuple of two strings for custom delimiters, or `nothing` to use defaults.

```julia
render_file(file::AbstractString, view::Dict{<:AbstractString}, tags=nothing) -> String
```

--------------------------------

### Implement badges for a Plugin

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Provides a method for the `badges` function to return a list of `Badge` objects, which are added to the `README.md` file to display project status or links.

```julia
badges(::Plugin) -> Union{Badge, Vector{Badge}}
```

--------------------------------

### Configure GitLab CI Integration

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Integrate your packages with GitLab CI. Specify the template file and whether to compute code coverage. Extra Julia versions can be listed. Nightly Julia is not supported. Documentation can be generated by including a `Documenter{GitLabCI}` plugin.

```julia
GitLabCI(;
    file="~/work/PkgTemplates.jl/PkgTemplates.jl/templates/gitlab-ci.yml",
    coverage=true,
    extra_versions=["1.10", "1.12"],
)
```

--------------------------------

### Configure Travis CI Integration

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Integrate your packages with Travis CI. Configure builds for Linux, OSX, Windows, and various architectures (x64, x86, arm64). You can also enable coverage and specify extra Julia versions. Another code coverage plugin such as `Codecov` must also be included for coverage to work.

```julia
TravisCI(;
    file="~/work/PkgTemplates.jl/PkgTemplates.jl/templates/travis.yml",
    linux=true,
    osx=false,
    windows=false,
    x64=true,
    x86=false,
    arm64=false,
    coverage=true,
    extra_versions=["1.10", "1.12", "nightly"],
)
```

--------------------------------

### PkgTemplates.combined_view

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Combines the default view and user-defined view for text templating purposes.

```APIDOC
## PkgTemplates.combined_view

### Description
This function combines `view` and `user_view` for use in text templating. If you're doing manual file creation or text templating (i.e. writing `Plugin`s that are not `FilePlugin`s), then you should use this function rather than either of the former two.
Note
Do not implement this function yourself! If you're implementing a plugin, you should implement `view`. If you're customizing a plugin as a user, you should implement `user_view`.

### Function Signature
```julia
combined_view(::Plugin, ::Template, pkg::AbstractString) -> Dict{String, Any}
```
```

--------------------------------

### Drone CI Plugin

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Configures Drone CI integration, with options for the template file, destination, and support for different architectures and Julia versions.

```APIDOC
## PkgTemplates.DroneCI

### Description
Integrates your packages with Drone CI.

### Constructor
```julia
DroneCI(; file="~/work/PkgTemplates.jl/PkgTemplates.jl/templates/drone.star", amd64=true, arm=false, arm64=false, extra_versions=["1.10", "1.12"])
```

### Keyword Arguments
* `file::AbstractString` : Template file for `.drone.star`.
* `destination::AbstractString`: File destination, relative to the repository root. For example, you might want to generate a `.drone.yml` instead of the default Starlark file.
* `amd64::Bool`: Whether or not to run builds on AMD64.
* `arm::Bool`: Whether or not to run builds on ARM (32-bit).
* `arm64::Bool`: Whether or not to run builds on ARM64.
* `extra_versions::Vector`: Extra Julia versions to test, as strings or `VersionNumber`s.

### Note
Nightly Julia is not supported.
```

--------------------------------

### PkgTemplates.tags

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Returns the delimiters used for text templating within a plugin.

```APIDOC
## PkgTemplates.tags

### Description
Return the delimiters used for text templating. See the `Citation` plugin for a rare case where changing the tags is necessary.
By default, the tags are `"{{"` and `"}}"`.

### Function Signature
```julia
tags(::Plugin) -> Tuple{String, String}
```
```

--------------------------------

### Interactive Package Creation

Source: https://juliaci.github.io/PkgTemplates.jl/stable

Create a new Julia package interactively by using Template(interactive=true). This will prompt for various options, showing defaults in parentheses.

```julia
using PkgTemplates
Template(interactive=true)("MyPkg")
```

--------------------------------

### Generate Package with Default Template

Source: https://juliaci.github.io/PkgTemplates.jl/stable

Use a previously created Template object to generate a new package. Ensure the template is configured before use.

```julia
tpl("MyPkg")
```

--------------------------------

### Configure TagBot Plugin

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Adds GitHub release support using TagBot. Customize workflow file, trigger user, secrets, and changelog options.

```julia
TagBot(
    file="~/work/PkgTemplates.jl/PkgTemplates.jl/templates/github/workflows/TagBot.yml",
    destination="TagBot.yml",
    trigger="JuliaTagBot",
    token=Secret("GITHUB_TOKEN"),
    ssh=Secret("DOCUMENTER_KEY"),
    ssh_password=nothing,
    changelog=nothing,
    changelog_ignore=nothing,
    gpg=nothing,
    gpg_password=nothing,
    registry=nothing,
    branches=nothing,
    dispatch=nothing,
    dispatch_delay=nothing,
)
```

--------------------------------

### Migrating Template Keywords

Source: https://juliaci.github.io/PkgTemplates.jl/stable/migrating

Update template keyword usage to the new plugin-based syntax. Non-default settings require explicit plugin instantiation.

```julia
plugins=[License(; name="ISC")]
```

```julia
plugins=[Develop()]
```

```julia
plugins=[!Git]
```

```julia
julia=v"1"
```

```julia
plugins=[Git(; ssh=true)]
```

```julia
plugins=[Git(; manifest=true)]
```

--------------------------------

### Plugin Hook Stage

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

The main stage of the package generation pipeline. `prehook`s have run, but `posthook`s have not. `pkg_dir` is the directory where the package is being generated.

```julia
hook(::Plugin, ::Template, pkg_dir::AbstractString)
```

--------------------------------

### Combine View and User View

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Combines `view` and `user_view` for text templating. Use this function for manual file creation or text templating if your plugin is not a `FilePlugin`.

```julia
combined_view(::Plugin, ::Template, pkg::AbstractString) -> Dict{String, Any}
```

--------------------------------

### Interactive Plugin Creation

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Function signature for interactively creating a plugin of a specific type.

```julia
interactive(T::Type{<:Plugin}) -> T
```

--------------------------------

### Plugin Types

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

PkgTemplates.jl offers three types of plugins for customization: Plugin, FilePlugin, and BadgePlugin.

```APIDOC
## PkgTemplates.Plugin — Type

Plugins are PkgTemplates' source of customization and extensibility. Add plugins to your `Template`s to enable extra pieces of repository setup.
When implementing a new plugin, subtype this type to have full control over its behaviour.

```

```APIDOC
## PkgTemplates.FilePlugin — Type

A simple plugin that, in general, creates a single file.

```

```APIDOC
## PkgTemplates.BadgePlugin — Type

A `Plugin` that only adds a `Badge` to the `Readme` file.
Concrete subtypes only need to implement a `badges` method.

```

--------------------------------

### Migrating Plugin Names

Source: https://juliaci.github.io/PkgTemplates.jl/stable/migrating

Note the renamings of common plugins like GitHubPages and GitLabPages to their Documenter equivalents.

```julia
Documenter{TravisCI}
```

```julia
Documenter{GitLabCI}
```

--------------------------------

### Codecov Plugin

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Sets up code coverage submission to Codecov.

```APIDOC
## PkgTemplates.Codecov

### Description
Sets up code coverage submission from CI to Codecov.

### Constructor
```julia
Codecov(; file=nothing)
```

### Keyword Arguments
* `file::Union{AbstractString, Nothing}` : Template file for `.codecov.yml`, or `nothing` to create no file.
```

--------------------------------

### Travis CI Plugin

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Configures Travis CI integration, allowing specification of operating systems, architectures, coverage, and extra Julia versions.

```APIDOC
## PkgTemplates.TravisCI

### Description
Integrates your packages with Travis CI.

### Constructor
```julia
TravisCI(; file="~/work/PkgTemplates.jl/PkgTemplates.jl/templates/travis.yml", linux=true, osx=false, windows=false, x64=true, x86=false, arm64=false, coverage=true, extra_versions=["1.10", "1.12", "nightly"])
```

### Keyword Arguments
* `file::AbstractString` : Template file for `.travis.yml`.
* `linux::Bool`: Whether or not to run builds on Linux.
* `osx::Bool`: Whether or not to run builds on OSX (MacOS).
* `windows::Bool`: Whether or not to run builds on Windows.
* `x64::Bool`: Whether or not to run builds on 64-bit architecture.
* `x86::Bool`: Whether or not to run builds on 32-bit architecture.
* `arm64::Bool`: Whether or not to run builds on the ARM64 architecture.
* `coverage::Bool`: Whether or not to publish code coverage. Another code coverage plugin such as `Codecov` must also be included.
* `extra_versions::Vector`: Extra Julia versions to test, as strings or `VersionNumber`s.
```

--------------------------------

### Format Version Numbers for CI

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Use `format_version` to strip a VersionNumber to its major and minor components. Strings are returned as-is. Useful for CI configurations.

```julia
format_version(v::Union{VersionNumber, AbstractString}) -> String
```

--------------------------------

### Serialize Template to a Binary File

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Use the `Serialization` package to save a template to a binary file. Note that the serialization format may not be stable across Julia versions.

```julia
const t = Template(; #= ... =#)
using Serialization
open(io -> serialize(io, t), "template.bin", "w")
```

--------------------------------

### Implement FilePlugin Hook

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Default hook implementation for FilePlugins. Generates a file based on source, view, and tags.

```julia
function render_plugin(p::FilePlugin, t::Template, pkg::AbstractString)
    return render_file(source(p), combined_view(p, t, pkg), tags(p))
end

function hook(p::FilePlugin, t::Template, pkg_dir::AbstractString)
    source(p) === nothing && return
    pkg = pkg_name(pkg_dir)
    path = joinpath(pkg_dir, destination(p))
    text = render_plugin(p, t, pkg)
    gen_file(path, text)
end
```

--------------------------------

### Generate Documenter.jl Keys

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Use this command to generate SSH keys for deploying documentation with Documenter.jl, particularly for GitHub Actions or Travis CI. Follow the instructions provided after execution.

```julia
using DocumenterTools; DocumenterTools.genkeys(user="MyUser", repo="MyPackage.jl")
```

--------------------------------

### Retrieve a Plugin from a Template

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Demonstrates the `getplugin` function, which allows retrieving a specific plugin of type `T` from a given `Template` object, returning `nothing` if the plugin is not present.

```julia
getplugin(t::Template, ::Type{T<:Plugin}) -> Union{T, Nothing}
```

--------------------------------

### Determine Plugin Processing Order

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Implement `priority` to define the order in which plugins are processed within each stage (higher values execute first). You can set priorities for specific stages (e.g., `typeof(hook)`) or for all stages.

```julia
priority(::Plugin, ::Union{typeof(prehook), typeof(hook), typeof(posthook)}) -> Int
```

--------------------------------

### Render Text with View

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Render arbitrary text with provided data. `tags` should be a tuple of two strings for custom delimiters, or `nothing` to use defaults.

```julia
render_text(text::AbstractString, view::Dict{<:AbstractString}, tags=nothing) -> String
```

--------------------------------

### Plugin Hook Functions

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Plugins can implement `prehook`, `hook`, and `posthook` functions to execute code at different stages of package generation.

```APIDOC
## PkgTemplates.prehook — Function

```
prehook(::Plugin, ::Template, pkg_dir::AbstractString)
```

Stage 1 of the package generation process (the "before" stage, in general). At this point, `pkg_dir` is an empty directory that will eventually contain the package, and neither the `hook`s nor the `posthook`s have run.
Note
`pkg_dir` only stays empty until the first plugin chooses to create a file. See also: `priority`.

```

```APIDOC
## PkgTemplates.hook — Function

```
hook(::Plugin, ::Template, pkg_dir::AbstractString)
```

Stage 2 of the package generation pipeline (the "main" stage, in general). At this point, the `prehook`s have run, but not the `posthook`s.
`pkg_dir` is the directory in which the package is being generated; `pkg_name`` will return the package name.
Note
You usually shouldn't implement this function for `FilePlugin`s. If you do, it should probably `invoke` the generic method (otherwise, there's not much reason to subtype `FilePlugin`).

```

```APIDOC
## PkgTemplates.posthook — Function

```
posthook(::Plugin, ::Template, pkg_dir::AbstractString)
```

Stage 3 of the package generation pipeline (the "after" stage, in general). At this point, both the `prehook`s and `hook`s have run.

```

--------------------------------

### Format Version Numbers for CI

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Use `compat_version` to format a VersionNumber, excluding trailing zero components. This is useful for CI configurations.

```julia
compat_version(v::VersionNumber) -> String
```

--------------------------------

### GitLab Project Template

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

A template configuration for projects hosted on GitLab, including GitLabCI and Documenter plugins.

```julia
Template(;
    user="my-username",
    host="gitlab.com",
    plugins=[
        GitLabCI(),
        Documenter{GitLabCI}(),
    ],
)
```

--------------------------------

### Configure Cirrus CI Integration

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Integrate your packages with Cirrus CI. You can specify the template file, the FreeBSD image to use, enable coverage, and list extra Julia versions. Note that Code coverage submission from Cirrus CI is not yet supported by Coverage.jl.

```julia
CirrusCI(;
    file="~/work/PkgTemplates.jl/PkgTemplates.jl/templates/cirrus.yml",
    image="freebsd-12-0-release-amd64",
    coverage=true,
    extra_versions=["1.10", "1.12", "nightly"],
)
```

--------------------------------

### GitLab CI Plugin

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Configures GitLab CI integration, with options for the template file, coverage, and extra Julia versions. Supports GitLab Pages documentation generation.

```APIDOC
## PkgTemplates.GitLabCI

### Description
Integrates your packages with GitLab CI.

### Constructor
```julia
GitLabCI(; file="~/work/PkgTemplates.jl/PkgTemplates.jl/templates/gitlab-ci.yml", coverage=true, extra_versions=["1.10", "1.12"])
```

### Keyword Arguments
* `file::AbstractString` : Template file for `.gitlab-ci.yml`.
* `coverage::Bool`: Whether or not to compute code coverage.
* `extra_versions::Vector`: Extra Julia versions to test, as strings or `VersionNumber`s.

### GitLab Pages
Documentation can be generated by including a `Documenter{GitLabCI}` plugin. See `Documenter` for more information.

### Note
Nightly Julia is not supported.
```

--------------------------------

### Input Conversion for Plugins

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Function signature for converting user string input to the appropriate type for a plugin field during interactive mode.

```julia
convert_input(::Type{P}, ::Type{T}, s::AbstractString) -> T
```

--------------------------------

### Generate File from Text

Source: https://juliaci.github.io/PkgTemplates.jl/stable/developer

Create a new file with the given text content. Trailing whitespace is removed, and the file will end with a newline.

```julia
gen_file(file::AbstractString, text::AbstractString)
```

--------------------------------

### CompatHelper Integration

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Integrates packages with CompatHelper via GitHub Actions. Deprecated in favor of Dependabot, but still available. The `file` argument specifies the template, `destination` the file path, and `cron` the schedule interval.

```julia
CompatHelper(;
    file="~/work/PkgTemplates.jl/PkgTemplates.jl/templates/github/workflows/CompatHelper.yml",
    destination="CompatHelper.yml",
    cron="0 0 * * *",
)
```

--------------------------------

### GitHubActions

Source: https://juliaci.github.io/PkgTemplates.jl/stable/user

Integrates the package with GitHub Actions for CI.

```APIDOC
## GitHubActions

### Description
Integrates your packages with GitHub Actions.

### Constructor
```julia
GitHubActions(; file="~/work/PkgTemplates.jl/PkgTemplates.jl/templates/github/workflows/CI.yml", destination="CI.yml", linux=true, osx=false, windows=false, x64=true, x86=false, coverage=true, extra_versions=["1.10", "1.12", "pre"])
```

### Keyword Arguments
* `file::AbstractString` - Template file for the workflow file.
* `destination::AbstractString` - Destination of the workflow file, relative to `.github/workflows`.
* `linux::Bool` - Whether or not to run builds on Linux.
* `osx::Bool` - Whether or not to run builds on OSX (MacOS).
* `windows::Bool` - Whether or not to run builds on Windows.
* `x64::Bool` - Whether or not to run builds on 64-bit architecture.
* `x86::Bool` - Whether or not to run builds on 32-bit architecture.
* `coverage::Bool` - Whether or not to publish code coverage. Another code coverage plugin such as `Codecov` must also be included.
* `extra_versions::Vector` - Extra Julia versions to test, as strings or `VersionNumber`s.
```
Tokens:
Raw