cake-build/cake

:cake: Cake (C# Make) is a cross platform build automation system.

Cake

Cake (C# Make) is a build automation system with a C# DSL to do things like compiling code, copy files/folders, running unit tests, compress files and build NuGet packages.

Runner	Latest Released	Latest Develop
Cake .NET Tool
Cake Frosting

Continuous integration

Build server	Platform	Build status	Integration tests
Azure Pipelines	MacOS
Azure Pipelines	Windows
Azure Pipelines	Debian
Azure Pipelines	Fedora
Azure Pipelines	Centos
Azure Pipelines	Ubuntu
AppVeyor	Windows
TeamCity	Windows
Bitrise	MacOS
Bitrise	Debian
Bitbucket Pipelines	Debian
GitLab	Debian
GitHub Actions	Windows / Ubuntu/ macOS

Code Coverage

Table of Contents

1. Documentation
2. Contributing
3. Get in touch
4. License

Documentation

You can read the latest documentation at https://cakebuild.net/.

For a simple example to get started see Setting up a new project.

Contributing

So you’re thinking about contributing to Cake? Great! It’s really appreciated.

Make sure you've read the contribution guidelines before sending that epic pull request. You'll also need to sign the contribution license agreement (CLA) for anything other than a trivial change. NOTE: The .NET Foundation CLA Bot will provide a link to this CLA within the PR that you submit if it is deemed as required.

• Fork the repository.
• Create a branch to work in.
• Make your feature addition or bug fix.
• Don't forget the unit tests.
• Send a pull request.

Get in touch

License

Copyright © .NET Foundation, Patrik Svensson, Mattias Karlsson, Gary Ewan Park, Alistair Chapman, Martin Björkström, Dave Glick, Pascal Berger, Jérémie Desautels, Enrico Campidoglio, C. Augusto Proiete, Nils Andresen, and contributors.

Cake is provided as-is under the MIT license. For more information see LICENSE.

• For Roslyn, see https://github.com/dotnet/roslyn/blob/master/License.txt
• For Autofac, see https://github.com/autofac/Autofac/blob/master/LICENSE
• For NuGet.Core, see https://github.com/NuGet/Home/blob/dev/LICENSE.txt

Thanks

A big thank you has to go to JetBrains who provide each of the Cake Developers with an Open Source License for ReSharper that helps with the development of Cake.

Sponsors

Our wonderful sponsors:

Backers

Our wonderful backers:

Code of Conduct

This project has adopted the code of conduct defined by the Contributor Covenant to clarify expected behavior in our community. For more information see the .NET Foundation Code of Conduct.

Contribution License Agreement

By signing the CLA, the community is free to use your contribution to .NET Foundation projects.

.NET Foundation

This project is supported by the .NET Foundation.

cake's Issues

Find external extension methods to ICakeContext and generate script aliases.

By analyzing the syntax tree and look for #r-directives, we can scan those assemblies for extension methods to ICakeContext and automatically generate script methods for these.

WiX support

• Candle
• Light

Add method to describe tasks

Add option to add a description to a task.

Task("Magic")
   .HasDescription("Performs magic")
   .Does(() =>
{
   DoMagic();
});

When starting Cake with the -showtasks parameter, the following output should be shown.

Tasks         Description
===============================
Magic         Performs magic

Log process launch parameters

When launching a process, the parameters should be written to the log (with diagnostic verbosity).

Cleaning directory should create it if missing

MSBuild: Find latest MSBuild if no tools version is specifed

ILMerge support

var outputAssembly = "./output/merged.exe";
var primaryAssembly = "./build/application.exe";
var assemblyPaths = GetFiles("/build/*.dll");

ILMerge(outputAssembly, primaryAssembly, assemblyPaths, 
    new ILMergeSettings {
        TargetKind = TargetKind.Exe,
        Internalize = true    
    }
);

MSTest support

Add build script

Windows Service controller support

JSLint support

xUnit support

• Run unit tests
• Shadow copying
• Output directory
• Xml report
• Html report

Add ContinueOnError option for tasks

MSBuild support

Features:

• Properties
• Targets
• Configuration
• 64 bit support (AMD64)
• Platform target support

Versions:

• Visual Studio 2013
• Visual Studio 2012
• Visual Studio 2010
• Visual Studio 2008
• Visual Studio 2005

Add tools path option

By convention, all external tools are located under ./tools/thetool/. All script extensions that uses external tools should have a tool path option, so the script can tell were to find them.

Task("NuGet")
    .IsDependentOn("Pack")
    .Does(() =>
{
    // Create NuGet package.
    NuGetPack("./Cake.nuspec", new NuGetPackSettings
    {
        Version = "0.1.0",
        BasePath = "./src/Cake/bin/" + configuration,
        OutputDirectory = "./build",
        NoPackageAnalysis = true,
        ToolPath = @"C:/NuGet.exe"
    });
});

Add support for parsing AssemblyInfo.cs files

• AssemblyVersion
• AssemblyFileVersion
• AssemblyInformationalVersion

NuGet Restore

MSBuild: Support MaxCpuCount

Should use /m if nothing is specified for MaxCpuCount.

Generate script host methods

At the moment, all script host methods exposing functionality from ICakeContext is hard coded. These should be generated before executing the script.

This will also eliminate the need for a separate script host (and a lot of redundant code).

Example

If this extension method is declared:

namespace MyStuff
{
   public static class MyFunctionality
   {
      public static void DoMagic(this ICakeContext context, int value)
      {
         context.Log.Verbose("Hello: {0}", value)
      }
   }
}

We could add a using statement to namespace MyStuff and generate a script method:

public void DoMagic(int value)
{
   ((ICakeContext)this).DoMagic(value);
}

Or call the extension method like a normal method:

public void DoMagic(int value)
{
   MyStuff.MyFunctionality.DoMagic((ICakeContext)this, value);
}

Rename Run to RunTarget

IO: Compression support

• Zip files
• Zip directory

Make a difference between running order and dependencies

A dependency is something that HAS to be run before something else. If it does not have to be run, it should allow the task to run anyway.

Task("First")
   .WithCriteria(() => shouldDoStuff)
   .Does(() =>
{
});

Task("Second")
   .RunsAfter("First")
   .Does(() =>
{
});

Task("Third")
   .IsDependentOn("Second")
   .Does(() =>
{
});

In the example before, the task Second will be run regardless if shouldDoStuff was true or not, Third is dependent on Second though, so if Second did not run, an exception will be thrown.

Unicorns.

Needs more unicorns. They are fabulous.

Steps to take

• add unicorn
• make sure it is fabulous
• ???
• profit

You can have mine.

Should throw if target wasn't found

Make task names case insensitive

TeamCity support

Should probably introduce script alias properties to make it cleaner and easier to use.

• Set build version
• Block opened/closed
• Progress message/start/finish
• Publish artifact

Script aliases:

// Detect if this is a team city build
bool IsTeamCityBuild();

// Set progress.
void SetTeamCityProgress("Building things");

// Start and finish progress scope.
void StartTeamCityProgress("Building things");
void FinishTeamCityProgress("Building thing");

// Set build version.
void SetTeamCityBuildVersion("1.0.0");

// Open and close message block.
void OpenTeamCityBlock("Run unit tests");
void CloseTeamCityBlock("Run unit tests");

// Publish artifact.
PublishTeamCityArtifact("./bin/**/*");

Convenience:

// Report progress
using(TeamCityProgress("Building things")
{
    // Do magic 
}

// Wrap operations in message block.
using(TeamCityBlock("Run unit tests"))
{
    // Do magic
}

Simplified task graph configuration

Simplified task graph configuration.

Graph("Clean")
   .Then("Build")
   .Then("Run-Unit-Tests", If(() => runTests))
   .Then("Copy-Files")
   .Then("Zip-Files", If(c => c.HasArgument("zipFiles")))
   .Then("Create-NuGet-Package")
   .Then("Publish-NuGet-Package", If(publish))
   .Then("All")

Add script alias methods that accept strings

• void CopyFiles(IEnumerable<string> files, DirectoryPath target)
• void CleanDirectories(IEnumerable<string> directories)
• void DeleteDirectories(IEnumerable<string> directories, bool recursive = false)
• void Zip(DirectoryPath root, FilePath output, IEnumerable<string> files)
• void XUnit(IEnumerable<string> assemblies)
• void XUnit(IEnumerable<string> assemblies, XUnitSettings settings)
• void NUnit(IEnumerable<string> assemblies)
• void NUnit(IEnumerable<string> assemblies, NUnitSettings settings)

Add support for loading scripts

Jasmin support

Custom collections for file and directory paths

They could also use operator overloading (+ and -) to make it easier to add and remove files. Globber should return these collections.

Examples

GetFiles("bin/**/*")
   .Remove(GetFiles("bin/**/*.md"))
   .Add(GetFiles("other/**/*.dll");

GetFiles("bin/**/*") 
   - GetFiles("bin/**/*.md") 
   + GetFiles("other/**/*.dll");

NuGet pack: Set nuspec metadata

• id
• title
• version
• authors
• owners
• description
• summary
• projectUrl
• iconUrl
• licenseUrl
• copyright
• requireLicenseAcceptance
• releaseNotes
• tags

Globbing functionality

Add CMake support?

Benchmark report

The Cake engine should return a benchmark report if the built went well.

Parse FAKE release notes

• Complex format
• Simple format

Should throw if two tasks have the same name

When validating the graph, throw an exception with a friendly error message if a task with the same name as the one that is being added already exist.

Add friendly name to tasks

The friendly name should be used when printing the task name in the output or presenting the task in the report.

Task("Unit-Tests")
    .HasFriendlyName("Run unit tests")
    .IsDependentOn("Build")
    .Does(() =>
{
    // Run unit tests.
    XUnit("./src/**/bin/" + configuration + "/*.Tests.dll");
});

NuGet packaging support

Start out with minimal package support.
For example; files, references and release notes have to be added as part of nuspec file, but version information can be passed to method directly.

Task("Create-NuGet-Package")
    .IsDependentOn("Build")
    .Does(() =>
{
    NuGetPack("./Cake.nuspec", new NuGetPackSettings {
        BasePath = "./build/bin",
        OutputDirectory = "./build",
        Version = "1.0.1",
        NoPackageAnalysis = true
    });
});

Templating support should be added later on.

FXCop support

IO: Clean and delete directories

• Clean directory
• Delete directory

Print script alias method to write to console

The Print method will append a line break to the information written.

Print("Hello World {0}", 1);

NuGet symbol package support

NUnit support

Support for creating AssemblyInfo.cs

Should be able to create AssemblyInfo files from build script.

Task graph visualization

Change build system for Cake

Logging

Cake script runner based on Roslyn

IO: File Copying