Cake: Command line - CI parameter - git info mapping

[tapika]

1. cake.frosten is possible to use as it's own command line builder executable. (cli)

2. it's also possible to use cake.frosten from ci - for example github actions or azure build pipelines. (ci)

3. sometimes getting information from cli is not suffient - it's also possible that when you run command locally -
   you can get same information from local environment - for example from git / git branch name.

typically if you want like simplified and smooth flow - maybe use 2 if it's ci, use 3 if 1 is not provided, and then finally use 1 if specified.

For example with git branch it would work like this:

public class CommandLineArgs : DefaultCommandLineArgs
{
    [CommandOption($"--{nameof(branch)}")]
    [Description("Forces specific branch name (by default autodetected)")]
    public string branch { get; set; }

...

if (!string.IsNullOrEmpty(cmdArgs.branch))
{
    branchName = cmdArgs.branch;
}
else
{
    // Azure devops
    branchName = this.BuildSystem().AzurePipelines.Environment.Repository.SourceBranch;
    if (string.IsNullOrEmpty(branchName))
    { 
        // Local
        branchName = this.GitBranchCurrent(RootDirectory).CanonicalName;
    }
}

Theoretically - I would prefer to generalize this even more. Let's say that I want to define parameter in ci, and then it would automatically create command line argument for cli tool and then I could get same kind of system out of box.

One approach - if for example we have all parameters defined in .yml file (also depends on ci build system) - maybe there should be automatic yaml parser, which somehow automatically maps yaml parameter to command line argument.

3 is not always available and not for all parameters / arguments, so it can be up to parameter whether it's autodetected or not.

3 is available for example for git url, which in theory can be even parsed further, which in a turn can be used with AzureDevOpsBuild (for example).

(Like get "my last successful" build, etc...)

Maybe there should be some sort of API to simplify 1-2-3 mapping ?

[tapika]

Adding piece of puzzle in here.

Azure's yaml format can be parsed using YamlDotNet.NetCore nuget package and code like this:

public class ParameterInfo
{ 
    public string name { get; set; }

    public string displayName { get; set; }

    public string type { get; set; }

    [YamlMember(Alias = "default")]
    public string defaultValue { get; set; }

    public List<string> values { get; set; }
}

public class AzureYamlConfig
{ 
    public List<ParameterInfo> parameters { get; set; }
}

...
string yamlFile = File.ReadAllText(Path.Combine(dir, "pipeline.yml"));
var deserializer = new DeserializerBuilder().IgnoreUnmatchedProperties().Build();
var yaml = deserializer.Deserialize<AzureYamlConfig>(yamlFile);

foreach (var p in yaml.parameters)
{
    Console.WriteLine($"parameter name: {p.name}, default value: '{p.defaultValue}'");
}

Theoretically it's possible to use tt4 templates to generate C# code which would be used for command line arguments parsing.

[tapika]

And using tt4 template it's possible to generate command line arguments for your tool.

Add as CommandLineArguments.tt file, and select CommandLineArguments.cs to be compiled as C# code.

<#@ template debug="false" hostspecific="false" language="C#" #>
<#@ assembly name="System.Core" #>
<#@ assembly name="System.Runtime" #>
<#@ assembly name="System.IO" #>
<#@ assembly name="$(SolutionDir)\..\packages\yamldotnet.netcore\1.0.0\lib\netstandard1.0\YamlDotNet.NetCore.dll" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.IO" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="YamlDotNet.Serialization" #>
<#@ output extension=".cs" #>
<#
GenerateCode();
#>
<#+ 
public class ParameterInfo
{ 
    public string name { get; set; }

    public string displayName { get; set; }

    public string type { get; set; }

    [YamlMember(Alias = "default")]
    public string defaultValue { get; set; }

    public List<string> values { get; set; }
}

public class AzureYamlConfig
{ 
    public List<ParameterInfo> parameters { get; set; }
}

void GenerateCode()
{
    string dir = System.Environment.CurrentDirectory;
    string yamlFile = File.ReadAllText(Path.Combine(dir, "..", "pipeline", "pipeline.yml"));
    var deserializer = new DeserializerBuilder().IgnoreUnmatchedProperties().Build();
    var yaml = deserializer.Deserialize<AzureYamlConfig>(yamlFile);

    WriteLine("using Spectre.Console.Cli;");
    WriteLine("using System.ComponentModel;");
    WriteLine("");

    WriteLine("namespace cakebuild");
    WriteLine("{");
    PushIndent("   ");
    
    WriteLine("public partial class CommandLineArgs {");
    PushIndent("   ");

    foreach (var p in yaml.parameters)
    {
        if(p.name == "noop")
        {
            continue;
        }

        var displayName = p.displayName.Replace("\"", "\\\"");
        var parameterType = p.type;
        
        bool isBoolean = parameterType == "boolean";
        if(isBoolean)
        {
            parameterType = "bool";
        } else {
            parameterType = "FlagValue<string>";
        }

        if(p.defaultValue != null)
        {
            string defaultValue = p.defaultValue;

            if(parameterType != "bool")
            {
                defaultValue = $"\"{p.defaultValue}\"";
            }

            WriteLine($"[DefaultValue({defaultValue})]");
        }
        
        string argTag = "";
        if(!isBoolean)
        {
            argTag = " [arg]";
        }
        
        WriteLine($"[CommandOption($\"--{{nameof({p.name})}}{argTag}\")]");

        WriteLine($"[Description(\"{displayName}\")]");
        
        WriteLine($"public {parameterType} {p.name} {{ get; set; }}");
     
        WriteLine("");
    }
    PopIndent();
    
    WriteLine("}");

    PopIndent();

    WriteLine("}");
}
#>