TemplateManager.Cli 1.0.8

Template Manager CLI

This tool was built to speed up the development of projects using a standard structure such as the Mediator pattern with a consistent handler/request/unit test.
The supported operating systems for this CLI is so far unknown, but it does work on windows machines.

Running the CLI

Once this Nuget package is installed, you can run the command tmplt in most command prompts to trigger the template process.
When you run the application for the first time, it will ask you if you want the CLI to create the CodeTemplates folder for you. This will be placed at {rootdrive}/CodeTemplates by default.
In addition, it will place a json file inside of it with a link to the Example folder also in the CodeTemplates folder.
This is to enable building up a template repository from many sources.
In order to replace this functionality, you can create a "CodeTemplates" folder in any folder location, and when running tmplt in a folder navigating down from the folder containing CodeTemplates, it will search for templates from the first occurence of a CodeTemplate folder.
There is an option in the CLI that allows you to navigate to root in case you want a template not specific to a solution.

Creating a template

Templates are just a regular file in a CodeTemplates folder that you want to create a copy of. The power comes in the templatising of variable names.
The ExampleFile contains most of the options available on a template level, there is also a section lower down explaining all of the options available.
Note that all variables are denoting with a two dollar symbols ('$').
An example is $EntityName$.
The following 2 sections will demonstrate how to create a file followed by how to create a file.

Creating a file.

An example of this being used is as follows, below is the collectio no variables. Note that anything wrapped in ${variable}$ will be read as a variable.

/*Usings removed for space*/
namespace $setting:namespace$;

public class $Action$$Domain$ : EndpointBaseSync.WithRequest<$Action$$Domain$Request>.WithActionResult<$ReturnType$>
{
  private readonly ILogger _logger;

  public $Action$$Domain$(ILogger<$Action$$Domain$> logger)
  {
    _logger = logger;
  }

  [AllowAnonymous]
  [Http$select:RequestType:Get|Post|Delete|Patch|Put$("$Action$")]
  [SwaggerOperation(
    Summary = "$Action$ $Domain:comment$",
    Description = "$Action$ $Domain:comment$",
    OperationId = "$Domain$.$Action$",
    Tags = new[] { "$Domain$Endpoint" })]
  public override ActionResult<$ReturnType$> Handle([FromQuery] $Action$$Domain$Request request)
  {
    return Ok();
  }
}

public class $Action$$Domain$Request
{
}

{Key} is used to denote a custom variable name that will be requested during the template construction process.

In situtations where you need a variable followed by text followed by another variabels (i.e. $if:IncludeX$X$endif:IncludeX$), you can use $ to break the search chain (i.e. $if:IncludeX$_$_X$endif:IncludeX$). The $ will be deleted afterwards.

Create a template group

The template groups are used to identify groupings of files that must be used together to create a greater fileset.
This is useful when you need to produce a file and an interface at the same time, or want to create your unit test at the same time as your handler.
The following example shows an API endpoint and an associated test:

Given the folder structure:

├── CodeTemplates
│   ├── ArdalisEndpoint.tmplt
│   ├── Endpoints
│   │   ├── EndpointWithRequest.cs
│   │   ├── EndpointWithRequestTest.cs

You can build a template group with the following code in the ArdalisEndpoint.tmplt:

{
  "ReplacementValues": [
  ],
  "Files": [
    {
      "FileName": "$Action$$Domain$.cs",
      "TemplateName": "Endpoints\\EndpointWithRequest.cs",
      "Destination": "$setting:solutionPath$\$setting:solution$.Api\\Endpoints\$Domain$\\",
      "Type": "File"
    },
    {
      "FileName": "$Action$$Domain$Test.cs",
      "TemplateName": "Endpoints\\EndpointWithRequestTest.cs",
      "Destination": "$setting:solutionPath$\$setting:solution$.Api.Tests\\Endpoints\$Domain$\\",
      "Type": "File"
    },
  ]
}

Development

In order to install this package, navigate to the TemplateManager.Cli project folder and run the folliwng in a CLI:
So from base you will run (for Windows):

cd .\TemplateManager.Cli\
dotnet pack
dotnet tool uninstall TemplateManager.Cli -g
dotnet tool install -g -v n --add-source ./nupkg TemplateManager.Cli

Repository

The repository for the code maintenance can be found at:
Template Manager on Github
Please note that it is currently un-unit tested, that is my next priority. It is a fairly major concern.

Template collection

It hasn't been built out yet, but I'm hoping to set up a template collection repository. Please feel free to contribute to it once it is set up.