build.cake

#addin nuget:?package=Cake.Xamarin&version=3.0.2
#addin nuget:?package=Cake.XCode&version=4.2.0
#addin nuget:?package=Cake.FileHelpers&version=3.2.1
#addin nuget:?package=Cake.Json&version=4.0.0
#addin nuget:?package=SharpCompress&version=0.24.0
#addin nuget:?package=Mono.ApiTools.NuGetDiff&version=1.3.0&loaddependencies=true
#addin nuget:?package=Xamarin.Nuget.Validator&version=1.1.1

#tool nuget:?package=mdoc&version=5.7.4.10
#tool nuget:?package=xunit.runner.console&version=2.4.1
#tool nuget:?package=vswhere&version=2.7.1

using System.Linq;
using System.Net.Http;
using System.Runtime.InteropServices;
using System.Text.RegularExpressions;
using System.Xml;
using System.Xml.Linq;
using SharpCompress.Common;
using SharpCompress.Readers;
using Mono.ApiTools;
using NuGet.Packaging;
using NuGet.Versioning;

DirectoryPath ROOT_PATH = MakeAbsolute(Directory("."));

#load "cake/shared.cake"
#load "cake/native-shared.cake"

var SKIP_EXTERNALS = Argument ("skipexternals", "")
    .ToLower ().Split (new [] { ',' }, StringSplitOptions.RemoveEmptyEntries);
var PACK_ALL_PLATFORMS = Argument ("packall", Argument ("PackAllPlatforms", false));
var BUILD_ALL_PLATFORMS = Argument ("buildall", Argument ("BuildAllPlatforms", false));
var PRINT_ALL_ENV_VARS = Argument ("printAllEnvVars", false);
var UNSUPPORTED_TESTS = Argument ("unsupportedTests", "");
var THROW_ON_TEST_FAILURE = Argument ("throwOnTestFailure", true);
var NUGET_DIFF_PRERELEASE = Argument ("nugetDiffPrerelease", false);
var COVERAGE = Argument ("coverage", false);

var PLATFORM_SUPPORTS_VULKAN_TESTS = (IsRunningOnWindows () || IsRunningOnLinux ()).ToString ();
var SUPPORT_VULKAN_VAR = Argument ("supportVulkan", EnvironmentVariable ("SUPPORT_VULKAN") ?? PLATFORM_SUPPORTS_VULKAN_TESTS);
var SUPPORT_VULKAN = SUPPORT_VULKAN_VAR == "1" || SUPPORT_VULKAN_VAR.ToLower () == "true";

var NuGetToolPath = Context.Tools.Resolve ("nuget.exe");
var CakeToolPath = Context.Tools.Resolve ("Cake.exe");
var MDocPath = Context.Tools.Resolve ("mdoc.exe");

DirectoryPath DOCS_PATH = MakeAbsolute(ROOT_PATH.Combine("docs/SkiaSharpAPI"));

var PREVIEW_LABEL = Argument ("previewLabel", EnvironmentVariable ("PREVIEW_LABEL") ?? "preview");
var FEATURE_NAME = EnvironmentVariable ("FEATURE_NAME") ?? "";
var BUILD_NUMBER = EnvironmentVariable ("BUILD_NUMBER") ?? "0";
var GIT_SHA = Argument ("gitSha", EnvironmentVariable ("GIT_SHA") ?? "");
var GIT_BRANCH_NAME = Argument ("gitBranch", EnvironmentVariable ("GIT_BRANCH_NAME") ?? "");

var PREVIEW_FEED_URL = "https://nugetized.blob.core.windows.net/skiasharp-eap/flatcontainer/{0}/{1}/{0}.{1}.nupkg"; // 0=id, 1=version

var TRACKED_NUGETS = new Dictionary<string, Version> {
    { "SkiaSharp",                                     new Version (1, 57, 0) },
    { "SkiaSharp.NativeAssets.Linux",                  new Version (1, 57, 0) },
    { "SkiaSharp.NativeAssets.Linux.NoDependencies",   new Version (1, 57, 0) },
    { "SkiaSharp.NativeAssets.NanoServer",             new Version (1, 57, 0) },
    { "SkiaSharp.NativeAssets.WebAssembly",            new Version (1, 57, 0) },
    { "SkiaSharp.Views",                               new Version (1, 57, 0) },
    { "SkiaSharp.Views.Desktop.Common",                new Version (1, 57, 0) },
    { "SkiaSharp.Views.Gtk2",                          new Version (1, 57, 0) },
    { "SkiaSharp.Views.Gtk3",                          new Version (1, 57, 0) },
    { "SkiaSharp.Views.WindowsForms",                  new Version (1, 57, 0) },
    { "SkiaSharp.Views.WPF",                           new Version (1, 57, 0) },
    { "SkiaSharp.Views.Forms",                         new Version (1, 57, 0) },
    { "SkiaSharp.Views.Forms.WPF",                     new Version (1, 57, 0) },
    { "SkiaSharp.Views.Forms.GTK",                     new Version (1, 57, 0) },
    { "SkiaSharp.Views.Uno",                           new Version (1, 57, 0) },
    { "HarfBuzzSharp",                                 new Version (1, 0, 0) },
    { "HarfBuzzSharp.NativeAssets.Linux",              new Version (1, 0, 0) },
    { "HarfBuzzSharp.NativeAssets.WebAssembly",        new Version (1, 0, 0) },
    { "SkiaSharp.HarfBuzz",                            new Version (1, 57, 0) },
    { "SkiaSharp.Vulkan.SharpVk",                      new Version (1, 57, 0) },
};

Information("Arguments:");
foreach (var arg in CAKE_ARGUMENTS) {
    Information($"    {arg.Key.PadRight(30)} {{0}}", arg.Value);
}

#load "cake/msbuild.cake"
#load "cake/UtilsManaged.cake"
#load "cake/externals.cake"
#load "cake/UpdateDocs.cake"
#load "cake/samples.cake"

Task ("__________________________________")
    .Description ("__________________________________________________");

////////////////////////////////////////////////////////////////////////////////////////////////////
// EXTERNALS - the native C and C++ libraries
////////////////////////////////////////////////////////////////////////////////////////////////////

// this builds all the externals
Task ("externals")
    .Description ("Build all external dependencies.")
    .IsDependentOn ("externals-native");

////////////////////////////////////////////////////////////////////////////////////////////////////
// LIBS - the managed C# libraries
////////////////////////////////////////////////////////////////////////////////////////////////////

Task ("libs")
    .Description ("Build all managed assemblies.")
    .IsDependentOn ("externals")
    .Does (() =>
{
    // build the managed libraries
    var platform = "";
    if (!BUILD_ALL_PLATFORMS) {
        if (IsRunningOnWindows ()) {
            platform = ".Windows";
        } else if (IsRunningOnMac ()) {
            platform = ".Mac";
        } else if (IsRunningOnLinux ()) {
            platform = ".Linux";
        }
    }
    RunMSBuild ($"./source/SkiaSharpSource{platform}.sln");

    // assemble the mdoc docs
    EnsureDirectoryExists ("./output/docs/mdoc/");
    RunProcess (MDocPath, new ProcessSettings {
        Arguments = $"assemble --out=\"./output/docs/mdoc/SkiaSharp\" \"{DOCS_PATH}\" --debug",
    });
    CopyFileToDirectory ("./docs/SkiaSharp.source", "./output/docs/mdoc/");
});

////////////////////////////////////////////////////////////////////////////////////////////////////
// TESTS - some test cases to make sure it works
////////////////////////////////////////////////////////////////////////////////////////////////////

Task ("tests")
    .Description ("Run all tests.")
    .IsDependentOn ("externals")
    .Does (() =>
{
    var failedTests = 0;

    void RunDesktopTest (string arch)
    {
        RunMSBuild ("./tests/SkiaSharp.Desktop.Tests.sln", platform: arch == "AnyCPU" ? "Any CPU" : arch);

        // SkiaSharp.Tests.dll
        try {
            RunTests ($"./tests/SkiaSharp.Desktop.Tests/bin/{arch}/{CONFIGURATION}/SkiaSharp.Tests.dll", arch == "x86");
        } catch {
            failedTests++;
        }

        // SkiaSharp.Vulkan.Tests.dll
        if (SUPPORT_VULKAN) {
            try {
                RunTests ($"./tests/SkiaSharp.Vulkan.Desktop.Tests/bin/{arch}/{CONFIGURATION}/SkiaSharp.Vulkan.Tests.dll", arch == "x86");
            } catch {
                failedTests++;
            }
        }
    }

    CleanDirectories ($"{PACKAGE_CACHE_PATH}/skiasharp*");
    CleanDirectories ($"{PACKAGE_CACHE_PATH}/harfbuzzsharp*");

    // Full .NET Framework
    if (IsRunningOnWindows ()) {
        RunDesktopTest ("x86");
        RunDesktopTest ("x64");
    } else if (IsRunningOnMac ()) {
        RunDesktopTest ("AnyCPU");
    } else if (IsRunningOnLinux ()) {
        RunDesktopTest ("x64");
    }

    // .NET Core

    // SkiaSharp.NetCore.Tests.csproj
    RunMSBuild ("./tests/SkiaSharp.NetCore.Tests.sln");
    try {
        RunNetCoreTests ("./tests/SkiaSharp.NetCore.Tests/SkiaSharp.NetCore.Tests.csproj");
    } catch {
        failedTests++;
    }

    // SkiaSharp.Vulkan.NetCore.Tests.csproj
    if (SUPPORT_VULKAN) {
        try {
            RunNetCoreTests ("./tests/SkiaSharp.Vulkan.NetCore.Tests/SkiaSharp.Vulkan.NetCore.Tests.csproj");
        } catch {
            failedTests++;
        }
    }

    if (failedTests > 0)
        if (THROW_ON_TEST_FAILURE)
            throw new Exception ($"There were {failedTests} failed tests.");
        else
            Warning ($"There were {failedTests} failed tests.");

    if (COVERAGE) {
        try {
            RunProcess ("reportgenerator", new ProcessSettings {
                Arguments = "-reports:./tests/**/Coverage/**/*.xml -targetdir:./output/coverage -reporttypes:HtmlInline_AzurePipelines;Cobertura"
            });
        } catch (Exception ex) {
            Error ("Make sure to install the 'dotnet-reportgenerator-globaltool' .NET Core global tool.");
            Error (ex);
            throw;
        }
        var xml = "./output/coverage/Cobertura.xml";
        var root = FindRegexMatchGroupsInFile (xml, @"<source>(.*)<\/source>", 0)[1].Value;
        ReplaceTextInFiles (xml, root, "");
    }
});

Task ("tests-wasm")
    .Description ("Run WASM tests.")
    .IsDependentOn ("externals-wasm")
    .Does (() =>
{
    var failedTests = 0;

    RunMSBuild ("./tests/SkiaSharp.Wasm.Tests.sln");

    var pubDir = "./tests/SkiaSharp.Wasm.Tests/bin/publish/";
    RunNetCorePublish("./tests/SkiaSharp.Wasm.Tests/SkiaSharp.Wasm.Tests.csproj", pubDir);
    IProcess serverProc = null;
    try {
        serverProc = RunAndReturnProcess(PYTHON_EXE, new ProcessSettings {
            Arguments = "server.py",
            WorkingDirectory = pubDir,
        });
        DotNetCoreRun("./utils/WasmTestRunner/WasmTestRunner.csproj", "http://localhost:8000/ -o ./tests/SkiaSharp.Wasm.Tests/TestResults/");
    } catch {
        failedTests++;
    } finally {
        serverProc?.Kill();
    }

    if (failedTests > 0)
        if (THROW_ON_TEST_FAILURE)
            throw new Exception ($"There were {failedTests} failed tests.");
        else
            Warning ($"There were {failedTests} failed tests.");
});

////////////////////////////////////////////////////////////////////////////////////////////////////
// SAMPLES - the demo apps showing off the work
////////////////////////////////////////////////////////////////////////////////////////////////////

Task ("samples-generate")
    .Description ("Generate and zip the samples directory structure.")
    .Does (() =>
{
    EnsureDirectoryExists ("./output/");

    // create the workbooks archive
    Zip ("./workbooks", "./output/workbooks.zip");

    // create the samples archive
    CreateSamplesDirectory ("./samples/", "./output/samples/");
    Zip ("./output/samples/", "./output/samples.zip");

    // create the preview samples archive
    var suffix = string.IsNullOrEmpty (BUILD_NUMBER)
        ? $"{PREVIEW_LABEL}"
        : $"{PREVIEW_LABEL}.{BUILD_NUMBER}";
    CreateSamplesDirectory ("./samples/", "./output/samples-preview/", suffix);
    Zip ("./output/samples-preview/", "./output/samples-preview.zip");
});

Task ("samples")
    .Description ("Build all samples.")
    .IsDependentOn ("samples-generate")
    .Does(() =>
{
    var isLinux = IsRunningOnLinux ();
    var isMac = IsRunningOnMac ();
    var isWin = IsRunningOnWindows ();

    var buildMatrix = new Dictionary<string, bool> {
        { "android", isMac || isWin },
        { "gtk", isLinux || isMac },
        { "ios", isMac },
        { "macos", isMac },
        { "tvos", isMac },
        { "uwp", isWin },
        { "watchos", isMac },
        { "wpf", isWin },
    };

    var platformMatrix = new Dictionary<string, string> {
        { "ios", "iPhone" },
        { "tvos", "iPhoneSimulator" },
        { "uwp", "x86" },
        { "watchos", "iPhoneSimulator" },
        { "xamarin.forms.mac", "iPhone" },
        { "xamarin.forms.windows", "x86" },
    };

    void BuildSample (FilePath sln)
    {
        var platform = sln.GetDirectory ().GetDirectoryName ().ToLower ();
        var name = sln.GetFilenameWithoutExtension ();
        var slnPlatform = name.GetExtension ();
        if (!string.IsNullOrEmpty (slnPlatform)) {
            slnPlatform = slnPlatform.ToLower ();
        }

        if (!buildMatrix.ContainsKey (platform) || buildMatrix [platform]) {
            string buildPlatform = null;
            if (!string.IsNullOrEmpty (slnPlatform)) {
                if (platformMatrix.ContainsKey (platform + slnPlatform)) {
                    buildPlatform = platformMatrix [platform + slnPlatform];
                }
            }
            if (string.IsNullOrEmpty (buildPlatform) && platformMatrix.ContainsKey (platform)) {
                buildPlatform = platformMatrix [platform];
            }

            RunNuGetRestorePackagesConfig (sln);
            RunMSBuild (sln, platform: buildPlatform);
        }
    }

    // build the newly migrated samples
    CleanDirectories ($"{PACKAGE_CACHE_PATH}/skiasharp*");
    CleanDirectories ($"{PACKAGE_CACHE_PATH}/harfbuzzsharp*");

    // TODO: Docker seems to be having issues on the old DevOps agents

    // // copy all the packages next to the Dockerfile files
    // var dockerfiles = GetFiles ("./output/samples/**/Dockerfile");
    // foreach (var dockerfile in dockerfiles) {
    //     CopyDirectory (OUTPUT_NUGETS_PATH, dockerfile.GetDirectory ().Combine ("packages"));
    // }

    // // build the run.ps1 (typically for Dockerfiles)
    // var runs = GetFiles ("./output/samples/**/run.ps1");
    // foreach (var run in runs) {
    //     RunProcess ("pwsh", new ProcessSettings {
    //         Arguments = run.FullPath,
    //         WorkingDirectory = run.GetDirectory (),
    //     });
    // }

    // build solutions locally
    var solutions = GetFiles ("./output/samples/**/*.sln");
    foreach (var sln in solutions) {
        var name = sln.GetFilenameWithoutExtension ();
        var slnPlatform = name.GetExtension ();

        if (string.IsNullOrEmpty (slnPlatform)) {
            // this is the main solution
            var variants = GetFiles (sln.GetDirectory ().CombineWithFilePath (name) + ".*.sln");
            if (!variants.Any ()) {
                // there is no platform variant
                BuildSample (sln);
            } else {
                // skip as there is a platform variant
            }
        } else {
            // this is a platform variant
            slnPlatform = slnPlatform.ToLower ();
            var shouldBuild =
                (isLinux && slnPlatform == ".linux") ||
                (isMac && slnPlatform == ".mac") ||
                (isWin && slnPlatform == ".windows");
            if (shouldBuild) {
                BuildSample (sln);
            } else {
                // skip this as this is not the correct platform
            }
        }
    }

    CleanDirectory ("./output/samples/");
    DeleteDirectory ("./output/samples/");
    CleanDirectory ("./output/samples-preview/");
    DeleteDirectory ("./output/samples-preview/");
});

////////////////////////////////////////////////////////////////////////////////////////////////////
// NUGET - building the package for NuGet.org
////////////////////////////////////////////////////////////////////////////////////////////////////

Task ("nuget")
    .Description ("Pack all NuGets (build all required dependencies).")
    .IsDependentOn ("libs")
    .Does (() =>
{
    var platform = "";
    if (!PACK_ALL_PLATFORMS) {
        if (IsRunningOnWindows ()) {
            platform = "windows";
        } else if (IsRunningOnMac ()) {
            platform = "macos";
        } else if (IsRunningOnLinux ()) {
            platform = "linux";
        }
    }

    void RemovePlatforms (XDocument xdoc)
    {
        var files = xdoc.Root
            .Elements ("files")
            .Elements ("file");
        foreach (var file in files.ToArray ()) {
            // remove the files that aren't available
            var nuspecPlatform = file.Attribute ("platform");
            if (!string.IsNullOrEmpty (nuspecPlatform?.Value)) {
                nuspecPlatform.Remove ();
                if (!string.IsNullOrEmpty (platform)) {
                    // handle the platform builds
                    if (!nuspecPlatform.Value.Split (',').Contains (platform)) {
                        file.Remove ();
                    }
                }
            }
            // copy the src attribute and set it for the target if there is none already
            if (string.IsNullOrEmpty (file.Attribute ("target")?.Value)) {
                file.Add (new XAttribute ("target", file.Attribute ("src").Value));
            }
            // make sure all the paths have the correct slash
            if (IsRunningOnWindows ()) {
                file.Attribute ("src").Value = file.Attribute ("src").Value.Replace ("/", "\\");
                file.Attribute ("target").Value = file.Attribute ("target").Value.Replace ("/", "\\");
            }
        }
    }

    void SetVersion (XDocument xdoc, string suffix)
    {
        var metadata = xdoc.Root.Element ("metadata");
        var id = metadata.Element ("id");
        var version = metadata.Element ("version");

        // <version>
        if (id != null && version != null) {
            var v = GetVersion (id.Value);
            if (!string.IsNullOrEmpty (v)) {
                if (id.Value.StartsWith("SkiaSharp") || id.Value.StartsWith("HarfBuzzSharp"))
                    v += suffix;
                version.Value = v;
            }
        }

        // <dependency>
        var dependencies = metadata
            .Elements ("dependencies")
            .Elements ("dependency");
        var groupDependencies = metadata
            .Elements ("dependencies")
            .Elements ("group")
            .Elements ("dependency");
        foreach (var package in dependencies.Union (groupDependencies)) {
            var depId = package.Attribute ("id");
            var depVersion = package.Attribute ("version");
            if (depId != null && depVersion != null) {
                var v = GetVersion (depId.Value);
                if (!string.IsNullOrEmpty (v)) {
                    if (depId.Value.StartsWith("SkiaSharp") || depId.Value.StartsWith("HarfBuzzSharp"))
                        v += suffix;
                    depVersion.Value = v;
                }
            }
        }
    }

    DeleteFiles ("./output/*/nuget/*.nuspec");
    foreach (var nuspec in GetFiles ("./nuget/*.nuspec")) {
        var xdoc = XDocument.Load (nuspec.FullPath);
        var metadata = xdoc.Root.Element ("metadata");
        var id = metadata.Element ("id").Value;
        if (id.StartsWith ("_"))
            continue;
        var dir = id;
        if (id.Contains(".NativeAssets.")) {
            dir = id.Substring(0, id.IndexOf(".NativeAssets."));
        }

        var preview = "";
        if (!string.IsNullOrEmpty (FEATURE_NAME)) {
            preview += $"-featurepreview-{FEATURE_NAME}";
        } else {
            preview += $"-{PREVIEW_LABEL}";
        }
        if (!string.IsNullOrEmpty (BUILD_NUMBER)) {
            preview += $".{BUILD_NUMBER}";
        }

        RemovePlatforms (xdoc);

        var outDir = $"./output/{dir}/nuget";
        EnsureDirectoryExists (outDir);

        SetVersion (xdoc, "");
        xdoc.Save ($"{outDir}/{id}.nuspec");

        SetVersion (xdoc, $"{preview}");
        xdoc.Save ($"{outDir}/{id}.prerelease.nuspec");

        // the placeholders
        FileWriteText ($"{outDir}/_._", "");

        // the legal
        CopyFile ("./LICENSE.txt", $"{outDir}/LICENSE.txt");
        CopyFile ("./External-Dependency-Info.txt", $"{outDir}/THIRD-PARTY-NOTICES.txt");
    }

    DeleteFiles ($"{OUTPUT_NUGETS_PATH}/*.nupkg");
    foreach (var nuspec in GetFiles ("./output/*/nuget/*.nuspec")) {
        PackageNuGet (nuspec, OUTPUT_NUGETS_PATH);
    }

    // setup validation options
    var options = new Xamarin.Nuget.Validator.NugetValidatorOptions {
        Copyright = "© Microsoft Corporation. All rights reserved.",
        Author = "Microsoft",
        Owner = "Microsoft",
        NeedsProjectUrl = true,
        NeedsLicenseUrl = true,
        ValidateRequireLicenseAcceptance = true,
        ValidPackageNamespace = new [] { "SkiaSharp", "HarfBuzzSharp" },
    };

    var nupkgFiles = GetFiles ($"{OUTPUT_NUGETS_PATH}/*.nupkg");

    Information ("Found ({0}) Nuget's to validate", nupkgFiles.Count ());

    foreach (var nupkgFile in nupkgFiles) {
        Verbose ("Verifiying Metadata of {0}", nupkgFile.GetFilename ());

        var result = Xamarin.Nuget.Validator.NugetValidator.Validate(MakeAbsolute(nupkgFile).FullPath, options);
        if (!result.Success) {
            Information ("Metadata validation failed for: {0} \n\n", nupkgFile.GetFilename ());
            Information (string.Join("\n    ", result.ErrorMessages));
            throw new Exception ($"Invalid Metadata for: {nupkgFile.GetFilename ()}");

        } else {
            Information ("Metadata validation passed for: {0}", nupkgFile.GetFilename ());
        }
    }

    // special case for all the native assets
    if (PACK_ALL_PLATFORMS)
    {
        EnsureDirectoryExists ($"{OUTPUT_SPECIAL_NUGETS_PATH}");
        DeleteFiles ($"{OUTPUT_SPECIAL_NUGETS_PATH}/*.nupkg");
        var specials = new Dictionary<string, string> {
            { "_NativeAssets", "native" },
            { "_NuGets", "nugets" },
        };
        foreach (var pair in specials) {
            DeleteFiles ($"./output/{pair.Value}/*.nuspec");

            var nuspec = $"./output/{pair.Value}/{pair.Key}.nuspec";

            // update the version
            var xdoc = XDocument.Load ($"./nuget/{pair.Key}.nuspec");
            var metadata = xdoc.Root.Element ("metadata");
            var version = metadata.Element ("version");

            if (!string.IsNullOrEmpty (PREVIEW_LABEL) && PREVIEW_LABEL.StartsWith ("pr.")) {
                version.Value = "0.0.0-" + PREVIEW_LABEL;
                xdoc.Save (nuspec);
                PackageNuGet (nuspec, OUTPUT_SPECIAL_NUGETS_PATH, true);
            } else {
                version.Value = "0.0.0-commit." + GIT_SHA;
                xdoc.Save (nuspec);
                PackageNuGet (nuspec, OUTPUT_SPECIAL_NUGETS_PATH, true);

                version.Value = "0.0.0-branch." + GIT_BRANCH_NAME.Replace ("/", ".");
                xdoc.Save (nuspec);
                PackageNuGet (nuspec, OUTPUT_SPECIAL_NUGETS_PATH, true);
            }

            DeleteFiles ($"./output/{pair.Value}/*.nuspec");
        }
    }
});

////////////////////////////////////////////////////////////////////////////////////////////////////
// DOCS - creating the xml, markdown and other documentation
////////////////////////////////////////////////////////////////////////////////////////////////////

Task ("update-docs")
    .Description ("Regenerate all docs.")
    .IsDependentOn ("docs-api-diff")
    .IsDependentOn ("docs-update-frameworks")
    .IsDependentOn ("docs-format-docs");

////////////////////////////////////////////////////////////////////////////////////////////////////
// CLEAN - remove all the build artefacts
////////////////////////////////////////////////////////////////////////////////////////////////////

Task ("clean")
    .Description ("Clean up.")
    .IsDependentOn ("clean-externals")
    .IsDependentOn ("clean-managed");

Task ("clean-managed")
    .Description ("Clean up (managed only).")
    .Does (() =>
{
    CleanDirectories ("./binding/*/bin");
    CleanDirectories ("./binding/*/obj");
    DeleteFiles ("./binding/*/project.lock.json");

    CleanDirectories ("./samples/*/*/bin");
    CleanDirectories ("./samples/*/*/obj");
    CleanDirectories ("./samples/*/*/AppPackages");
    CleanDirectories ("./samples/*/*/*/bin");
    CleanDirectories ("./samples/*/*/*/obj");
    DeleteFiles ("./samples/*/*/*/project.lock.json");
    CleanDirectories ("./samples/*/*/*/AppPackages");
    CleanDirectories ("./samples/*/*/packages");

    CleanDirectories ("./tests/**/bin");
    CleanDirectories ("./tests/**/obj");
    CleanDirectories ("./tests/**/artifacts");
    DeleteFiles ("./tests/**/project.lock.json");

    CleanDirectories ("./source/*/*/bin");
    CleanDirectories ("./source/*/*/obj");
    DeleteFiles ("./source/*/*/project.lock.json");
    CleanDirectories ("./source/*/*/Generated Files");
    CleanDirectories ("./source/packages");

    DeleteFiles ("./nuget/*.prerelease.nuspec");

    if (DirectoryExists ("./output"))
        DeleteDirectory ("./output", true);
});

////////////////////////////////////////////////////////////////////////////////////////////////////
// DEFAULT - target for common development
////////////////////////////////////////////////////////////////////////////////////////////////////

Task ("----------------------------------")
    .Description ("--------------------------------------------------");

Task ("Default")
    .Description ("Build all managed assemblies and external dependencies.")
    .IsDependentOn ("externals")
    .IsDependentOn ("libs");

Task ("Everything")
    .Description ("Build, pack and test everything.")
    .IsDependentOn ("externals")
    .IsDependentOn ("libs")
    .IsDependentOn ("nuget")
    .IsDependentOn ("tests")
    .IsDependentOn ("samples");

////////////////////////////////////////////////////////////////////////////////////////////////////
// BUILD NOW
////////////////////////////////////////////////////////////////////////////////////////////////////

RunTarget (TARGET);