mono
/
SkiaSharp
зеркало из https://github.com/mono/SkiaSharp.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
SkiaSharp/build.cake

665 строки
25 KiB
C#
Исходник Ответственный История

#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);
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку