Skip to content

Instantly share code, notes, and snippets.

@bjorkstromm

bjorkstromm/build.cake

Created December 4, 2019 21:30
Show Gist options
  • Save bjorkstromm/9e55c33b4d63a7b90c3e37cc183eee32 to your computer and use it in GitHub Desktop.
Save bjorkstromm/9e55c33b4d63a7b90c3e37cc183eee32 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
build.cake
#line 1 "B3437BF2-8AE3-4281-8726-B926BB9DF75D"
/// <summary>
/// Determines whether or not the specified argument exist.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="name">The argument name.</param>
/// <returns>Whether or not the specified argument exist.</returns>
/// <example>
/// This sample shows how to call the <see cref="M:Cake.Common.ArgumentAliases.HasArgument(Cake.Core.ICakeContext,System.String)" /> method.
/// <code>
/// var argumentName = "myArgument";
/// //Cake.exe .\hasargument.cake -myArgument="is specified"
/// if (HasArgument(argumentName))
/// {
/// Information("{0} is specified", argumentName);
/// }
/// //Cake.exe .\hasargument.cake
/// else
/// {
/// Warning("{0} not specified", argumentName);
/// }
/// </code>
/// </example>
public System.Boolean HasArgument(System.String name)
{
return Cake.Common.ArgumentAliases.HasArgument(Context, name);
}
/// <summary>
/// Gets an argument and throws if the argument is missing.
/// </summary>
/// <typeparam name="T">The argument type.</typeparam>
/// <param name="context">The context.</param>
/// <param name="name">The argument name.</param>
/// <returns>The value of the argument.</returns>
/// <example>
/// <code>
/// //Cake.exe .\argument.cake -myArgument="is valid" -loopCount = 5
/// Information("Argument {0}", Argument&lt;string&gt;("myArgument"));
/// var loopCount = Argument&lt;int&gt;("loopCount");
/// for(var index = 0;index&lt;loopCount; index++)
/// {
/// Information("Index {0}", index);
/// }
/// </code>
/// </example>
/// <exception cref="T:Cake.Core.CakeException">Argument value is null.</exception>
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="context" /> is null.</exception>
public T Argument<T>(System.String name)
{
return Cake.Common.ArgumentAliases.Argument<T>(Context, name);
}
/// <summary>
/// Gets an argument and returns the provided <paramref name="defaultValue" /> if the argument is missing.
/// </summary>
/// <typeparam name="T">The argument type.</typeparam>
/// <param name="context">The context.</param>
/// <param name="name">The argument name.</param>
/// <param name="defaultValue">The value to return if the argument is missing.</param>
/// <returns>The value of the argument if it exist; otherwise <paramref name="defaultValue" />.</returns>
/// <example>
/// <code>
/// //Cake.exe .\argument.cake -myArgument="is valid" -loopCount = 5
/// Information("Argument {0}", Argument&lt;string&gt;("myArgument", "is NOT valid"));
/// var loopCount = Argument&lt;int&gt;("loopCount", 10);
/// for(var index = 0;index&lt;loopCount; index++)
/// {
/// Information("Index {0}", index);
/// }
/// </code>
/// </example>
public T Argument<T>(System.String name, T defaultValue)
{
return Cake.Common.ArgumentAliases.Argument<T>(Context, name, defaultValue);
}
/// <summary>
/// Retrieves the value of the environment variable or <c>null</c> if the environment variable does not exist.
/// </summary>
/// <example>
/// <code>
/// Information(EnvironmentVariable("HOME") ?? "Unknown location");
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="variable">The environment variable.</param>
/// <returns>The environment variable or <c>null</c> if the environment variable does not exist.</returns>
public System.String EnvironmentVariable(System.String variable)
{
return Cake.Common.EnvironmentAliases.EnvironmentVariable(Context, variable);
}
/// <summary>
/// Retrieves all environment variables
/// </summary>
/// <example>
/// <code>
/// var envVars = EnvironmentVariables();
///
/// string path;
/// if (envVars.TryGetValue("PATH", out path))
/// {
/// Information("Path: {0}", path);
/// }
///
/// foreach(var envVar in envVars)
/// {
/// Information(
/// "Key: {0}\tValue: \"{1}\"",
/// envVar.Key,
/// envVar.Value
/// );
/// }
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <returns>The environment variables</returns>
public System.Collections.Generic.IDictionary<System.String, System.String> EnvironmentVariables()
{
return Cake.Common.EnvironmentAliases.EnvironmentVariables(Context);
}
/// <summary>
/// Checks for the existence of a value for a given environment variable.
/// </summary>
/// <example>
/// <code>
/// if (HasEnvironmentVariable("SOME_ENVIRONMENT_VARIABLE"))
/// {
/// Information("The environment variable was present.");
/// }
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="variable">The environment variable.</param>
/// <returns>
/// <c>true</c> if the environment variable exist; otherwise <c>false</c>.
/// </returns>
public System.Boolean HasEnvironmentVariable(System.String variable)
{
return Cake.Common.EnvironmentAliases.HasEnvironmentVariable(Context, variable);
}
/// <summary>
/// Determines whether the build script is running on Windows.
/// </summary>
/// <example>
/// <code>
/// if (IsRunningOnWindows())
/// {
/// Information("Windows!");
/// }
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <returns>
/// <c>true</c> if the build script is running on Windows; otherwise <c>false</c>.
/// </returns>
public System.Boolean IsRunningOnWindows()
{
return Cake.Common.EnvironmentAliases.IsRunningOnWindows(Context);
}
/// <summary>
/// Determines whether the build script running on a Unix or Linux based system.
/// </summary>
/// <example>
/// <code>
/// if (IsRunningOnUnix())
/// {
/// Information("Not Windows!");
/// }
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <returns>
/// <c>true</c> if the build script running on a Unix or Linux based system; otherwise <c>false</c>.
/// </returns>
public System.Boolean IsRunningOnUnix()
{
return Cake.Common.EnvironmentAliases.IsRunningOnUnix(Context);
}
/// <summary>
/// Starts the process resource that is specified by the filename.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="fileName">The file name.</param>
/// <returns>The exit code that the started process specified when it terminated.</returns>
/// <example>
/// <code>
/// var exitCodeWithoutArguments = StartProcess("ping");
/// // This should output 1 as argument is missing
/// Information("Exit code: {0}", exitCodeWithoutArguments);
/// </code>
/// </example>
public System.Int32 StartProcess(Cake.Core.IO.FilePath fileName)
{
return Cake.Common.ProcessAliases.StartProcess(Context, fileName);
}
/// <summary>
/// Starts the process resource that is specified by the filename and arguments
/// </summary>
/// <param name="context">The context.</param>
/// <param name="fileName">Name of the file.</param>
/// <param name="processArguments">The arguments used in the process settings.</param>
/// <returns>The exit code that the started process specified when it terminated.</returns>
/// <example>
/// <code>
/// var exitCodeWithArgument = StartProcess("ping", "localhost");
/// // This should output 0 as valid arguments supplied
/// Information("Exit code: {0}", exitCodeWithArgument);
/// </code>
/// </example>
public System.Int32 StartProcess(Cake.Core.IO.FilePath fileName, System.String processArguments)
{
return Cake.Common.ProcessAliases.StartProcess(Context, fileName, processArguments);
}
/// <summary>
/// Starts the process resource that is specified by the filename and settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="fileName">Name of the file.</param>
/// <param name="settings">The settings.</param>
/// <returns>The exit code that the started process specified when it terminated.</returns>
/// <example>
/// <code>
/// var exitCodeWithArgument = StartProcess("ping", new ProcessSettings{ Arguments = "localhost" });
/// // This should output 0 as valid arguments supplied
/// Information("Exit code: {0}", exitCodeWithArgument);
/// </code>
/// </example>
public System.Int32 StartProcess(Cake.Core.IO.FilePath fileName, Cake.Core.IO.ProcessSettings settings)
{
return Cake.Common.ProcessAliases.StartProcess(Context, fileName, settings);
}
public System.Int32 StartProcess(Cake.Core.IO.FilePath fileName, Cake.Core.IO.ProcessSettings settings, out System.Collections.Generic.IEnumerable<System.String> redirectedStandardOutput)
{
return Cake.Common.ProcessAliases.StartProcess(Context, fileName, settings, out redirectedStandardOutput);
}
public System.Int32 StartProcess(Cake.Core.IO.FilePath fileName, Cake.Core.IO.ProcessSettings settings, out System.Collections.Generic.IEnumerable<System.String> redirectedStandardOutput, out System.Collections.Generic.IEnumerable<System.String> redirectedErrorOutput)
{
return Cake.Common.ProcessAliases.StartProcess(Context, fileName, settings, out redirectedStandardOutput, out redirectedErrorOutput);
}
/// <summary>
/// Starts the process resource that is specified by the filename and settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="fileName">Name of the file.</param>
/// <param name="settings">The settings.</param>
/// <returns>The newly started process.</returns>
/// <example>
/// <code>
/// using(var process = StartAndReturnProcess("ping", new ProcessSettings{ Arguments = "localhost" }))
/// {
/// process.WaitForExit();
/// // This should output 0 as valid arguments supplied
/// Information("Exit code: {0}", process.GetExitCode());
/// }
/// </code>
/// </example>
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="context" />, <paramref name="fileName" />, or <paramref name="settings" /> is null.</exception>
public Cake.Core.IO.IProcess StartAndReturnProcess(Cake.Core.IO.FilePath fileName, Cake.Core.IO.ProcessSettings settings)
{
return Cake.Common.ProcessAliases.StartAndReturnProcess(Context, fileName, settings);
}
/// <summary>
/// Starts the process resource that is specified by the filename.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="fileName">Name of the file.</param>
/// <returns>The newly started process.</returns>
/// <example>
/// <code>
/// using(var process = StartAndReturnProcess("ping"))
/// {
/// process.WaitForExit();
/// // This should output 0 as valid arguments supplied
/// Information("Exit code: {0}", process.GetExitCode());
/// }
/// </code>
/// </example>
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="context" />, <paramref name="fileName" /> is null.</exception>
public Cake.Core.IO.IProcess StartAndReturnProcess(Cake.Core.IO.FilePath fileName)
{
return Cake.Common.ProcessAliases.StartAndReturnProcess(Context, fileName);
}
/// <summary>
/// Parses all release notes.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The file path.</param>
/// <returns>All release notes.</returns>
/// <example>
/// <code>
/// var releaseNotes = ParseAllReleaseNotes("./ReleaseNotes.md");
/// foreach(var releaseNote in releaseNotes)
/// {
/// Information("Version: {0}", releaseNote.Version);
/// foreach(var note in releaseNote.Notes)
/// {
/// Information("\t{0}", note);
/// }
/// }
/// </code>
/// </example>
public System.Collections.Generic.IReadOnlyList<Cake.Common.ReleaseNotes> ParseAllReleaseNotes(Cake.Core.IO.FilePath filePath)
{
return Cake.Common.ReleaseNotesAliases.ParseAllReleaseNotes(Context, filePath);
}
/// <summary>
/// Parses the latest release notes.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The file path.</param>
/// <returns>The latest release notes.</returns>
/// <example>
/// <code>
/// var releaseNote = ParseReleaseNotes("./ReleaseNotes.md");
/// Information("Version: {0}", releaseNote.Version);
/// foreach(var note in releaseNote.Notes)
/// {
/// Information("\t{0}", note);
/// }
/// </code>
/// </example>
public Cake.Common.ReleaseNotes ParseReleaseNotes(Cake.Core.IO.FilePath filePath)
{
return Cake.Common.ReleaseNotesAliases.ParseReleaseNotes(Context, filePath);
}
/// <summary>
/// Gets the value of a target node.
/// </summary>
/// <returns>The value found at the given XPath query.</returns>
/// <param name="context">The context.</param>
/// <param name="filePath">The target file.</param>
/// <param name="xpath">The xpath of the node to get.</param>
/// <example>
/// <code>
/// string autoFacVersion = XmlPeek("./src/Cake/packages.config", "/packages/package[@id='Autofac']/@version");
/// </code>
/// </example>
public System.String XmlPeek(Cake.Core.IO.FilePath filePath, System.String xpath)
{
return Cake.Common.Xml.XmlPeekAliases.XmlPeek(Context, filePath, xpath);
}
/// <summary>
/// Get the value of a target node.
/// </summary>
/// <returns>The value found at the given XPath query.</returns>
/// <param name="context">The context.</param>
/// <param name="filePath">The target file.</param>
/// <param name="xpath">The xpath of the nodes to set.</param>
/// <param name="settings">Additional settings to tweak Xml Peek behavior.</param>
/// <example>
/// <code>
/// <para>XML document:</para>
/// <![CDATA[
/// <?xml version="1.0" encoding="UTF-8"?>
/// <pastery xmlns = "https://cakebuild.net/pastery" >
/// <cake price="1.62" />
/// </pastery>
/// ]]>
/// </code>
/// <para>XmlPeek usage:</para>
/// <code>
/// string version = XmlPeek("./pastery.xml", "/pastery:pastery/pastery:cake/@price",
/// new XmlPeekSettings {
/// Namespaces = new Dictionary&lt;string, string&gt; {{ "pastery", "https://cakebuild.net/pastery" }}
/// });
/// string unknown = XmlPeek("./pastery.xml", "/pastery:pastery/pastery:cake/@recipe",
/// new XmlPeekSettings {
/// Namespaces = new Dictionary&lt;string, string&gt; {{ "pastery", "https://cakebuild.net/pastery" }},
/// SuppressWarning = true
/// });
/// </code>
/// </example>
public System.String XmlPeek(Cake.Core.IO.FilePath filePath, System.String xpath, Cake.Common.Xml.XmlPeekSettings settings)
{
return Cake.Common.Xml.XmlPeekAliases.XmlPeek(Context, filePath, xpath, settings);
}
/// <summary>
/// Set the value of, or remove, target nodes.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The target file.</param>
/// <param name="xpath">The xpath of the nodes to set.</param>
/// <param name="value">The value to set too. Leave blank to remove the selected nodes.</param>
/// <example>
/// <para>
/// Change the <c>server</c> setting in the configuration from <c>testhost.somecompany.com</c>
/// to <c>productionhost.somecompany.com</c>.
/// </para>
/// <para>XML file:</para>
/// <code>
/// <![CDATA[
/// <?xml version="1.0" encoding="utf-8" ?>
/// <configuration>
/// <appSettings>
/// <add key="server" value="testhost.somecompany.com" />
/// </appSettings>
/// </configuration>
/// ]]>
/// </code>
/// <para>Cake Task:</para>
/// <code>
/// <![CDATA[
/// Task("Transform")
/// .Does(() =>
/// {
/// var file = File("test.xml");
/// XmlPoke(file, "/configuration/appSettings/add[@key = 'server']/@value", "productionhost.somecompany.com");
/// });
/// ]]>
/// </code>
/// </example>
/// <example>
/// <para>
/// Modify the <c>noNamespaceSchemaLocation</c> in an XML file.
/// </para>
/// <para>XML file:</para>
/// <code>
/// <![CDATA[
/// <?xml version="1.0" encoding="utf-8" ?>
/// <Commands xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Path Value">
/// </Commands>
/// ]]>
/// </code>
/// <para>Cake Task:</para>
/// <code>
/// <![CDATA[
/// Task("Transform")
/// .Does(() =>
/// {
/// var file = File("test.xml");
/// XmlPoke(file, "/Commands/@xsi:noNamespaceSchemaLocation", "d:\\Commands.xsd", new XmlPokeSettings {
/// Namespaces = new Dictionary<string, string> {
/// { /* Prefix */ "xsi", /* URI */ "http://www.w3.org/2001/XMLSchema-instance" }
/// }
/// });
/// });
/// ]]>
/// </code>
/// <example>
/// <para>
/// Remove an app setting from a config file.
/// </para>
/// <para>XML file:</para>
/// <code>
/// <![CDATA[
/// <?xml version="1.0" encoding="utf-8" ?>
/// <configuration>
/// <appSettings>
/// <add key="server" value="testhost.somecompany.com" />
/// <add key="testing" value="true" />
/// </appSettings>
/// </configuration>
/// ]]>
/// </code>
/// <para>Cake Task:</para>
/// <code>
/// <![CDATA[
/// Task("Transform")
/// .Does(() =>
/// {
/// var file = File("test.xml");
/// XmlPoke(file, "/configuration/appSettings/add[@testing]", null);
/// });
/// ]]>
/// </code>
/// </example>
/// <para>
/// Credit to NAnt for the original example.
/// http://nant.sourceforge.net/release/latest/help/tasks/xmlpoke.html
/// </para>
/// </example>
public void XmlPoke(Cake.Core.IO.FilePath filePath, System.String xpath, System.String value)
{
Cake.Common.Xml.XmlPokeAliases.XmlPoke(Context, filePath, xpath, value);
}
/// <summary>
/// Set the value of, or remove, target nodes.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The target file.</param>
/// <param name="xpath">The xpath of the nodes to set.</param>
/// <param name="value">The value to set too. Leave blank to remove the selected nodes.</param>
/// <param name="settings">Additional settings to tweak Xml Poke behavior.</param>
/// <example>
/// <para>
/// Change the <c>server</c> setting in the configuration from <c>testhost.somecompany.com</c>
/// to <c>productionhost.somecompany.com</c>.
/// </para>
/// <para>XML file:</para>
/// <code>
/// <![CDATA[
/// <?xml version="1.0" encoding="utf-8" ?>
/// <configuration>
/// <appSettings>
/// <add key="server" value="testhost.somecompany.com" />
/// </appSettings>
/// </configuration>
/// ]]>
/// </code>
/// <para>Cake Task:</para>
/// <code>
/// <![CDATA[
/// Task("Transform")
/// .Does(() =>
/// {
/// var file = File("test.xml");
/// XmlPoke(file, "/configuration/appSettings/add[@key = 'server']/@value", "productionhost.somecompany.com");
/// });
/// ]]>
/// </code>
/// </example>
/// <example>
/// <para>
/// Modify the <c>noNamespaceSchemaLocation</c> in an XML file.
/// </para>
/// <para>XML file:</para>
/// <code>
/// <![CDATA[
/// <?xml version="1.0" encoding="utf-8" ?>
/// <Commands xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Path Value">
/// </Commands>
/// ]]>
/// </code>
/// <para>Cake Task:</para>
/// <code>
/// <![CDATA[
/// Task("Transform")
/// .Does(() =>
/// {
/// var file = File("test.xml");
/// XmlPoke(file, "/Commands/@xsi:noNamespaceSchemaLocation", "d:\\Commands.xsd", new XmlPokeSettings {
/// Namespaces = new Dictionary<string, string> {
/// { /* Prefix */ "xsi", /* URI */ "http://www.w3.org/2001/XMLSchema-instance" }
/// }
/// });
/// });
/// ]]>
/// </code>
/// <example>
/// <para>
/// Remove an app setting from a config file.
/// </para>
/// <para>XML file:</para>
/// <code>
/// <![CDATA[
/// <?xml version="1.0" encoding="utf-8" ?>
/// <configuration>
/// <appSettings>
/// <add key="server" value="testhost.somecompany.com" />
/// <add key="testing" value="true" />
/// </appSettings>
/// </configuration>
/// ]]>
/// </code>
/// <para>Cake Task:</para>
/// <code>
/// <![CDATA[
/// Task("Transform")
/// .Does(() =>
/// {
/// var file = File("test.xml");
/// XmlPoke(file, "/configuration/appSettings/add[@testing]", null);
/// });
/// ]]>
/// </code>
/// </example>
/// <para>
/// Credit to NAnt for the original example.
/// http://nant.sourceforge.net/release/latest/help/tasks/xmlpoke.html
/// </para>
/// </example>
public void XmlPoke(Cake.Core.IO.FilePath filePath, System.String xpath, System.String value, Cake.Common.Xml.XmlPokeSettings settings)
{
Cake.Common.Xml.XmlPokeAliases.XmlPoke(Context, filePath, xpath, value, settings);
}
/// <summary>
/// Set the value of, or remove, target nodes.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="sourceXml">The source xml to transform.</param>
/// <param name="xpath">The xpath of the nodes to set.</param>
/// <param name="value">The value to set too. Leave blank to remove the selected nodes.</param>
/// <returns>Resulting XML.</returns>
/// <example>
/// <para>
/// Change the <c>server</c> setting in the configuration from <c>testhost.somecompany.com</c>
/// to <c>productionhost.somecompany.com</c>.
/// </para>
/// <para>XML string:</para>
/// <code>
/// <![CDATA[
/// <?xml version="1.0" encoding="utf-8" ?>
/// <configuration>
/// <appSettings>
/// <add key="server" value="testhost.somecompany.com" />
/// </appSettings>
/// </configuration>
/// ]]>
/// </code>
/// <para>Cake Task:</para>
/// <code>
/// <![CDATA[
/// Task("Transform")
/// .Does(() =>
/// {
/// var result = XmlPokeString(xmlString, "/configuration/appSettings/add[@key = 'server']/@value", "productionhost.somecompany.com");
/// });
/// ]]>
/// </code>
/// </example>
/// <example>
/// <para>
/// Modify the <c>noNamespaceSchemaLocation</c> in an XML file.
/// </para>
/// <para>XML string:</para>
/// <code>
/// <![CDATA[
/// <?xml version="1.0" encoding="utf-8" ?>
/// <Commands xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Path Value">
/// </Commands>
/// ]]>
/// </code>
/// <para>Cake Task:</para>
/// <code>
/// <![CDATA[
/// Task("Transform")
/// .Does(() =>
/// {
/// var result = XmlPokeString(xmlString, "/Commands/@xsi:noNamespaceSchemaLocation", "d:\\Commands.xsd", new XmlPokeSettings {
/// Namespaces = new Dictionary<string, string> {
/// { /* Prefix */ "xsi", /* URI */ "http://www.w3.org/2001/XMLSchema-instance" }
/// }
/// });
/// });
/// ]]>
/// </code>
/// <example>
/// <para>
/// Remove an app setting from a config file.
/// </para>
/// <para>XML string:</para>
/// <code>
/// <![CDATA[
/// <?xml version="1.0" encoding="utf-8" ?>
/// <configuration>
/// <appSettings>
/// <add key="server" value="testhost.somecompany.com" />
/// <add key="testing" value="true" />
/// </appSettings>
/// </configuration>
/// ]]>
/// </code>
/// <para>Cake Task:</para>
/// <code>
/// <![CDATA[
/// Task("Transform")
/// .Does(() =>
/// {
/// var result = XmlPokeString(xmlString, "/configuration/appSettings/add[@testing]", null);
/// });
/// ]]>
/// </code>
/// </example>
/// <para>
/// Credit to NAnt for the original example.
/// http://nant.sourceforge.net/release/latest/help/tasks/xmlpoke.html
/// </para>
/// </example>
public System.String XmlPokeString(System.String sourceXml, System.String xpath, System.String value)
{
return Cake.Common.Xml.XmlPokeAliases.XmlPokeString(Context, sourceXml, xpath, value);
}
/// <summary>
/// Set the value of, or remove, target nodes.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="sourceXml">The source xml to transform.</param>
/// <param name="xpath">The xpath of the nodes to set.</param>
/// <param name="value">The value to set too. Leave blank to remove the selected nodes.</param>
/// <param name="settings">Additional settings to tweak Xml Poke behavior.</param>
/// <returns>Resulting XML.</returns>
/// <example>
/// <para>
/// Change the <c>server</c> setting in the configuration from <c>testhost.somecompany.com</c>
/// to <c>productionhost.somecompany.com</c>.
/// </para>
/// <para>XML string:</para>
/// <code>
/// <![CDATA[
/// <?xml version="1.0" encoding="utf-8" ?>
/// <configuration>
/// <appSettings>
/// <add key="server" value="testhost.somecompany.com" />
/// </appSettings>
/// </configuration>
/// ]]>
/// </code>
/// <para>Cake Task:</para>
/// <code>
/// <![CDATA[
/// Task("Transform")
/// .Does(() =>
/// {
/// var result = XmlPokeString(xmlString, "/configuration/appSettings/add[@key = 'server']/@value", "productionhost.somecompany.com");
/// });
/// ]]>
/// </code>
/// </example>
/// <example>
/// <para>
/// Modify the <c>noNamespaceSchemaLocation</c> in an XML file.
/// </para>
/// <para>XML string:</para>
/// <code>
/// <![CDATA[
/// <?xml version="1.0" encoding="utf-8" ?>
/// <Commands xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Path Value">
/// </Commands>
/// ]]>
/// </code>
/// <para>Cake Task:</para>
/// <code>
/// <![CDATA[
/// Task("Transform")
/// .Does(() =>
/// {
/// var result = XmlPokeString(xmlString, "/Commands/@xsi:noNamespaceSchemaLocation", "d:\\Commands.xsd", new XmlPokeSettings {
/// Namespaces = new Dictionary<string, string> {
/// { /* Prefix */ "xsi", /* URI */ "http://www.w3.org/2001/XMLSchema-instance" }
/// }
/// });
/// });
/// ]]>
/// </code>
/// <example>
/// <para>
/// Remove an app setting from a config file.
/// </para>
/// <para>XML string:</para>
/// <code>
/// <![CDATA[
/// <?xml version="1.0" encoding="utf-8" ?>
/// <configuration>
/// <appSettings>
/// <add key="server" value="testhost.somecompany.com" />
/// <add key="testing" value="true" />
/// </appSettings>
/// </configuration>
/// ]]>
/// </code>
/// <para>Cake Task:</para>
/// <code>
/// <![CDATA[
/// Task("Transform")
/// .Does(() =>
/// {
/// var result = XmlPokeString(xmlString, "/configuration/appSettings/add[@testing]", null);
/// });
/// ]]>
/// </code>
/// </example>
/// <para>
/// Credit to NAnt for the original example.
/// http://nant.sourceforge.net/release/latest/help/tasks/xmlpoke.html
/// </para>
/// </example>
public System.String XmlPokeString(System.String sourceXml, System.String xpath, System.String value, Cake.Common.Xml.XmlPokeSettings settings)
{
return Cake.Common.Xml.XmlPokeAliases.XmlPokeString(Context, sourceXml, xpath, value, settings);
}
/// <summary>
/// Performs XML XSL transformation
/// </summary>
/// <param name="context">The context.</param>
/// <param name="xsl">XML style sheet.</param>
/// <param name="xml">XML data.</param>
/// <returns>Transformed XML string.</returns>
/// <example>
/// <code>
/// <para>This example code will convert xml to a new xml strucure using XmlTransform alias.</para>
/// <![CDATA[
/// string xsl = @"<xsl:stylesheet version=""1.0"" xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"">
/// <xsl:output method=""xml"" omit-xml-declaration=""yes"" />
/// <xsl:template match=""/"">
/// <xsl:for-each select=""pastery/cake"" >
/// <price><xsl:value-of select=""@price""/></price>
/// </xsl:for-each>
/// </xsl:template>
/// </xsl:stylesheet>";
///
/// string xml = @"<?xml version=""1.0"" encoding=""UTF-8""?>
/// <pastery>
/// <cake price=""1.62"" />
/// </pastery>";
///
/// var priceTag = XmlTransform(xsl, xml);
/// ]]>
/// </code>
/// <para>Result:</para>
/// <code>
/// <![CDATA[<price>1.62</price>]]>
/// </code>
/// </example>
public System.String XmlTransform(System.String xsl, System.String xml)
{
return Cake.Common.Xml.XmlTransformationAlias.XmlTransform(Context, xsl, xml);
}
/// <summary>
/// Performs XML XSL transformation
/// </summary>
/// <param name="context">The context.</param>
/// <param name="xsl">XML style sheet.</param>
/// <param name="xml">XML data.</param>
/// <param name="settings">Optional settings for result file xml writer</param>
/// <returns>Transformed XML string.</returns>
/// <example>
/// <code>
/// <para>This example code will convert specific part of xml to plaintext using XmlTransform alias.</para>
/// <![CDATA[string xsl = @"<xsl:stylesheet version=""1.0"" xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"">
/// <xsl:output method=""text"" omit-xml-declaration=""yes"" indent=""no""/>
/// <xsl:strip-space elements=""*""/>
/// <xsl:template match=""pastery/cake""><xsl:value-of select=""@price""/></xsl:template>
/// </xsl:stylesheet>";
///
/// string xml = @"<?xml version=""1.0"" encoding=""UTF-8""?>
/// <pastery>
/// <cake price=""1.62"" />
/// </pastery>";
///
/// var text = XmlTransform(xsl, xml, new XmlTransformationSettings {
/// ConformanceLevel = System.Xml.ConformanceLevel.Fragment, Encoding = Encoding.ASCII });
/// ]]>
/// </code>
/// </example>
public System.String XmlTransform(System.String xsl, System.String xml, Cake.Common.Xml.XmlTransformationSettings settings)
{
return Cake.Common.Xml.XmlTransformationAlias.XmlTransform(Context, xsl, xml, settings);
}
/// <summary>
/// Performs XML XSL transformation
/// </summary>
/// <param name="context">The context.</param>
/// <param name="xslPath">Path to xml style sheet.</param>
/// <param name="xmlPath">Path xml data.</param>
/// <param name="resultPath">Transformation result path, will overwrite if exists.</param>
/// <example>
/// <code>
/// <para>This example code will convert the Cake nuspec into html using the XmlTransform alias.</para>
/// <para>XML stylesheet:</para>
/// <![CDATA[
/// <?xml version="1.0" ?>
/// <xsl:stylesheet
/// version="1.0"
/// xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
/// xmlns:p="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd"
/// exclude-result-prefixes="p"
/// >
/// <xsl:output method="xml" indent="yes" omit-xml-declaration="yes" />
/// <xsl:template match="/">
/// <html lang="en" class="static">
/// <head>
/// <title>
/// <xsl:for-each select="package/p:metadata">
/// <xsl:value-of select="p:id"/>
/// </xsl:for-each>
/// </title>
/// </head>
/// <body>
/// <xsl:for-each select="package/p:metadata">
/// <h1>
/// <xsl:value-of select="p:id"/>
/// </h1>
/// <h2>Description</h2>
/// <i><xsl:value-of select="p:description"/></i>
/// </xsl:for-each>
/// <h3>Files</h3>
/// <ul>
/// <xsl:for-each select="package/files/file" >
/// <li><xsl:value-of select="@src"/></li>
/// </xsl:for-each>
/// </ul>
/// </body>
/// </html>
/// </xsl:template>
/// </xsl:stylesheet>
/// ]]>
/// </code>
/// <para>XmlTransform usage:</para>
/// <code>
/// XmlTransform("./nuspec.xsl", "./nuspec/Cake.nuspec", "./Cake.htm");
/// </code>
/// </example>
public void XmlTransform(Cake.Core.IO.FilePath xslPath, Cake.Core.IO.FilePath xmlPath, Cake.Core.IO.FilePath resultPath)
{
Cake.Common.Xml.XmlTransformationAlias.XmlTransform(Context, xslPath, xmlPath, resultPath);
}
/// <summary>
/// Performs XML XSL transformation
/// </summary>
/// <param name="context">The context.</param>
/// <param name="xslPath">Path to xml style sheet.</param>
/// <param name="xmlPath">Path xml data.</param>
/// <param name="resultPath">Transformation result path.</param>
/// <param name="settings">Optional settings for result file xml writer</param>
/// <example>
/// <code>
/// <para>This example code will convert the Cake nuspec into html using the XmlTransform alias,
/// specifying that result should be indented and using Unicode encoding.</para>
/// <para>XML stylesheet:</para>
/// <![CDATA[
/// <?xml version="1.0" ?>
/// <xsl:stylesheet
/// version="1.0"
/// xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
/// xmlns:p="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd"
/// exclude-result-prefixes="p"
/// >
/// <xsl:output method="xml" indent="yes" omit-xml-declaration="yes" />
/// <xsl:template match="/">
/// <html lang="en" class="static">
/// <head>
/// <title>
/// <xsl:for-each select="package/p:metadata">
/// <xsl:value-of select="p:id"/>
/// </xsl:for-each>
/// </title>
/// </head>
/// <body>
/// <xsl:for-each select="package/p:metadata">
/// <h1>
/// <xsl:value-of select="p:id"/>
/// </h1>
/// <h2>Description</h2>
/// <i><xsl:value-of select="p:description"/></i>
/// </xsl:for-each>
/// <h3>Files</h3>
/// <ul>
/// <xsl:for-each select="package/files/file" >
/// <li><xsl:value-of select="@src"/></li>
/// </xsl:for-each>
/// </ul>
/// </body>
/// </html>
/// </xsl:template>
/// </xsl:stylesheet>
/// ]]>
/// </code>
/// <para>XmlTransform usage:</para>
/// <code>
/// XmlTransform("./nuspec.xsl", "./nuspec/Cake.nuspec", "./Cake.htm",
/// new XmlTransformationSettings { Indent = true, Encoding = Encoding.Unicode});
/// </code>
/// </example>
public void XmlTransform(Cake.Core.IO.FilePath xslPath, Cake.Core.IO.FilePath xmlPath, Cake.Core.IO.FilePath resultPath, Cake.Common.Xml.XmlTransformationSettings settings)
{
Cake.Common.Xml.XmlTransformationAlias.XmlTransform(Context, xslPath, xmlPath, resultPath, settings);
}
/// <summary>
/// Calculates the hash for a given file using the default (SHA256) algorithm.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The file path.</param>
/// <returns>A <see cref="T:Cake.Common.Security.FileHash" /> instance representing the calculated hash.</returns>
/// <example>
/// <code>
/// Information(
/// "Cake executable file SHA256 hash: {0}",
/// CalculateFileHash("Cake.exe").ToHex());
/// </code>
/// </example>
public Cake.Common.Security.FileHash CalculateFileHash(Cake.Core.IO.FilePath filePath)
{
return Cake.Common.Security.SecurityAliases.CalculateFileHash(Context, filePath);
}
/// <summary>
/// Calculates the hash for a given file.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The file path.</param>
/// <param name="hashAlgorithm">The hash algorithm to use.</param>
/// <returns>A <see cref="T:Cake.Common.Security.FileHash" /> instance representing the calculated hash.</returns>
/// <example>
/// <code>
/// Information(
/// "Cake executable file MD5 hash: {0}",
/// CalculateFileHash("Cake.exe", HashAlgorithm.MD5).ToHex());
/// </code>
/// </example>
public Cake.Common.Security.FileHash CalculateFileHash(Cake.Core.IO.FilePath filePath, Cake.Common.Security.HashAlgorithm hashAlgorithm)
{
return Cake.Common.Security.SecurityAliases.CalculateFileHash(Context, filePath, hashAlgorithm);
}
/// <summary>
/// Builds the specified solution using MSBuild or XBuild.
/// </summary>
/// <example>
/// <code>
/// DotNetBuild("./project/project.sln");
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="solution">The solution.</param>
public void DotNetBuild(Cake.Core.IO.FilePath solution)
{
Context.Log.Warning("Warning: The alias DotNetBuild has been made obsolete. Use MSBuild or XBuild instead.");
#pragma warning disable 0618
Cake.Common.Tools.DotNetBuildAliases.DotNetBuild(Context, solution);
#pragma warning restore 0618
}
/// <summary>
/// Builds the specified solution using MSBuild or XBuild.
/// </summary>
/// <example>
/// <code>
/// DotNetBuild("./project/project.sln", settings =&gt;
/// settings.SetConfiguration("Debug")
/// .SetVerbosity(Core.Diagnostics.Verbosity.Minimal)
/// .WithTarget("Build")
/// .WithProperty("TreatWarningsAsErrors","true"));
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="solution">The solution.</param>
/// <param name="configurator">The configurator.</param>
public void DotNetBuild(Cake.Core.IO.FilePath solution, System.Action<Cake.Common.Tools.DotNetBuildSettings> configurator)
{
Context.Log.Warning("Warning: The alias DotNetBuild has been made obsolete. Use MSBuild or XBuild instead.");
#pragma warning disable 0618
Cake.Common.Tools.DotNetBuildAliases.DotNetBuild(Context, solution, configurator);
#pragma warning restore 0618
}
/// <summary>
/// Gets the legacy Visual Studio product installation paths.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="latest">Get the latest version.</param>
/// <returns>The Visual Studio installation path.</returns>
/// <example>
/// <code>
/// var legacyInstallationPath = VSWhereLegacy(true);
/// </code>
/// </example>
public Cake.Core.IO.DirectoryPath VSWhereLegacy(System.Boolean latest)
{
return Cake.Common.Tools.VSWhere.VSWhereAliases.VSWhereLegacy(Context, latest);
}
/// <summary>
/// Gets the legacy Visual Studio product installation paths.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="settings">The settings.</param>
/// <returns>The Visual Studio installation paths.</returns>
/// <example>
/// <code>
/// var legacyInstallationPaths = VSWhereLegacy(new VSWhereLegacySettings());
/// </code>
/// </example>
public Cake.Core.IO.DirectoryPathCollection VSWhereLegacy(Cake.Common.Tools.VSWhere.Legacy.VSWhereLegacySettings settings)
{
return Cake.Common.Tools.VSWhere.VSWhereAliases.VSWhereLegacy(Context, settings);
}
/// <summary>
/// Gets the latest Visual Studio product installation path.
/// </summary>
/// <param name="context">The context.</param>
/// <returns>The Visual Studio installation path.</returns>
/// <example>
/// <code>
/// var latestInstallationPath = VSWhereLatest();
/// </code>
/// </example>
public Cake.Core.IO.DirectoryPath VSWhereLatest()
{
return Cake.Common.Tools.VSWhere.VSWhereAliases.VSWhereLatest(Context);
}
/// <summary>
/// Gets the latest Visual Studio product installation path.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="settings">The settings.</param>
/// <returns>The Visual Studio installation path.</returns>
/// <example>
/// <code>
/// var latestInstallationPath = VSWhereLatest(new VSWhereLatestSettings { Requires = "'Microsoft.Component.MSBuild" });
/// </code>
/// </example>
public Cake.Core.IO.DirectoryPath VSWhereLatest(Cake.Common.Tools.VSWhere.Latest.VSWhereLatestSettings settings)
{
return Cake.Common.Tools.VSWhere.VSWhereAliases.VSWhereLatest(Context, settings);
}
/// <summary>
/// Gets all Visual Studio product installation paths.
/// </summary>
/// <param name="context">The context.</param>
/// <returns>The Visual Studio installation paths.</returns>
/// <example>
/// <code>
/// var latestInstallationPaths = VSWhereAll();
/// </code>
/// </example>
public Cake.Core.IO.DirectoryPathCollection VSWhereAll()
{
return Cake.Common.Tools.VSWhere.VSWhereAliases.VSWhereAll(Context);
}
/// <summary>
/// Gets all Visual Studio product installation paths.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="settings">The settings.</param>
/// <returns>The Visual Studio installation paths.</returns>
/// <example>
/// <code>
/// var latestInstallationPaths = VSWhereAll(new VSWhereAllSettings { Requires = "'Microsoft.Component.MSBuild" });
/// </code>
/// </example>
public Cake.Core.IO.DirectoryPathCollection VSWhereAll(Cake.Common.Tools.VSWhere.All.VSWhereAllSettings settings)
{
return Cake.Common.Tools.VSWhere.VSWhereAliases.VSWhereAll(Context, settings);
}
/// <summary>
/// Gets Visual Studio product installation paths.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="products">The products to find.</param>
/// <returns>The Visual Studio installation paths.</returns>
/// <example>
/// <code>
/// var latestInstallationPaths = VSWhereProducts("Microsoft.VisualStudio.Product.BuildTools");
/// </code>
/// </example>
public Cake.Core.IO.DirectoryPathCollection VSWhereProducts(System.String products)
{
return Cake.Common.Tools.VSWhere.VSWhereAliases.VSWhereProducts(Context, products);
}
/// <summary>
/// Gets Visual Studio product installation paths.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="products">The products to find.</param>
/// <param name="settings">The settings.</param>
/// <returns>The Visual Studio installation paths.</returns>
/// <example>
/// <code>
/// var latestInstallationPaths = VSWhereProducts("Microsoft.VisualStudio.Product.BuildTools", new VSWhereProductSettings { Requires = "'Microsoft.Component.MSBuild" });
/// </code>
/// </example>
public Cake.Core.IO.DirectoryPathCollection VSWhereProducts(System.String products, Cake.Common.Tools.VSWhere.Product.VSWhereProductSettings settings)
{
return Cake.Common.Tools.VSWhere.VSWhereAliases.VSWhereProducts(Context, products, settings);
}
/// <summary>
/// Runs all VSTest unit tests in the assemblies matching the specified pattern.
/// </summary>
/// <example>
/// <code>
/// VSTest("./Tests/*.UnitTests.dll");
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
public void VSTest(System.String pattern)
{
Cake.Common.Tools.VSTest.VSTestAliases.VSTest(Context, pattern);
}
/// <summary>
/// Runs all VSTest unit tests in the assemblies matching the specified pattern.
/// </summary>
/// <example>
/// <code>
/// VSTest("./Tests/*.UnitTests.dll", new VSTestSettings() { Logger = VSTestLogger.Trx });
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="settings">The settings.</param>
public void VSTest(System.String pattern, Cake.Common.Tools.VSTest.VSTestSettings settings)
{
Cake.Common.Tools.VSTest.VSTestAliases.VSTest(Context, pattern, settings);
}
/// <summary>
/// Runs all VSTest unit tests in the specified assemblies.
/// </summary>
/// <example>
/// <code>
/// var paths = new List&lt;FilePath&gt;() { "./assemblydir1", "./assemblydir2" };
/// VSTest(paths);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="assemblyPaths">The assembly paths.</param>
public void VSTest(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblyPaths)
{
Cake.Common.Tools.VSTest.VSTestAliases.VSTest(Context, assemblyPaths);
}
/// <summary>
/// Runs all VSTest unit tests in the specified assemblies.
/// </summary>
/// <example>
/// <code>
/// var paths = new List&lt;FilePath&gt;() { "./assemblydir1", "./assemblydir2" };
/// VSTest(paths, new VSTestSettings() { InIsolation = true });
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="assemblyPaths">The assembly paths.</param>
/// <param name="settings">The settings.</param>
public void VSTest(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblyPaths, Cake.Common.Tools.VSTest.VSTestSettings settings)
{
Cake.Common.Tools.VSTest.VSTestAliases.VSTest(Context, assemblyPaths, settings);
}
/// <summary>
/// Transform a text template.
/// </summary>
/// <example>
/// <code>
/// // Transform a .tt template.
/// var transform = File("./src/Cake/Transform.tt");
/// TransformTemplate(transform);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="sourceFile">The source file.</param>
public void TransformTemplate(Cake.Core.IO.FilePath sourceFile)
{
Cake.Common.Tools.TextTransform.TextTransformAliases.TransformTemplate(Context, sourceFile);
}
/// <summary>
/// Transform a text template.
/// </summary>
/// <example>
/// <code>
/// // Transform a .tt template.
/// var transform = File("./src/Cake/Transform.tt");
/// TransformTemplate(transform, new TextTransformSettings { OutputFile="./src/Cake/Transform.cs" });
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="sourceFile">The source file.</param>
/// <param name="settings">The settings.</param>
public void TransformTemplate(Cake.Core.IO.FilePath sourceFile, Cake.Common.Tools.TextTransform.TextTransformSettings settings)
{
Cake.Common.Tools.TextTransform.TextTransformAliases.TransformTemplate(Context, sourceFile, settings);
}
/// <summary>
/// Creates a report that shows the usage and binding status of the steps for the entire project.
/// You can use this report to find both unused code in the automation layer and scenario steps that have no definition yet.
/// See <see href="https://github.com/techtalk/SpecFlow/wiki/Reporting#step-definition-report">SpecFlow Documentation</see> for more information.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="projectFile">The path of the project file containing the feature files.</param>
public void SpecFlowStepDefinitionReport(Cake.Core.IO.FilePath projectFile)
{
Cake.Common.Tools.SpecFlow.SpecFlowAliases.SpecFlowStepDefinitionReport(Context, projectFile);
}
/// <summary>
/// Creates a report that shows the usage and binding status of the steps for the entire project.
/// You can use this report to find both unused code in the automation layer and scenario steps that have no definition yet.
/// See <see href="https://github.com/techtalk/SpecFlow/wiki/Reporting#step-definition-report">SpecFlow Documentation</see> for more information.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="projectFile">The path of the project file containing the feature files.</param>
/// <param name="settings">The settings.</param>
public void SpecFlowStepDefinitionReport(Cake.Core.IO.FilePath projectFile, Cake.Common.Tools.SpecFlow.StepDefinitionReport.SpecFlowStepDefinitionReportSettings settings)
{
Cake.Common.Tools.SpecFlow.SpecFlowAliases.SpecFlowStepDefinitionReport(Context, projectFile, settings);
}
/// <summary>
/// Creates a formatted HTML report of a test execution.
/// The report contains a summary about the executed tests and the result and also a detailed report for the individual scenario executions.
/// See <see href="https://github.com/techtalk/SpecFlow/wiki/Reporting#test-execution-report">SpecFlow Documentation</see> for more information.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="action">The action to run SpecFlow for. Supported actions are: MSTest, NUnit3 and XUnit2</param>
/// <param name="projectFile">The path of the project file containing the feature files.</param>
public void SpecFlowTestExecutionReport(System.Action<Cake.Core.ICakeContext> action, Cake.Core.IO.FilePath projectFile)
{
Cake.Common.Tools.SpecFlow.SpecFlowAliases.SpecFlowTestExecutionReport(Context, action, projectFile);
}
/// <summary>
/// Creates a formatted HTML report of a test execution.
/// The report contains a summary about the executed tests and the result and also a detailed report for the individual scenario executions.
/// See <see href="https://github.com/techtalk/SpecFlow/wiki/Reporting#test-execution-report">SpecFlow Documentation</see> for more information.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="action">The action to run SpecFlow for. Supported actions are: MSTest, NUNit, NUNit3, XUnit and XUnit2</param>
/// <param name="projectFile">The path of the project file containing the feature files.</param>
/// <param name="settings">The settings.</param>
public void SpecFlowTestExecutionReport(System.Action<Cake.Core.ICakeContext> action, Cake.Core.IO.FilePath projectFile, Cake.Common.Tools.SpecFlow.TestExecutionReport.SpecFlowTestExecutionReportSettings settings)
{
Cake.Common.Tools.SpecFlow.SpecFlowAliases.SpecFlowTestExecutionReport(Context, action, projectFile, settings);
}
/// <summary>
/// Converts the reports in the specified directory into human readable form.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="inputFolder">The input folder.</param>
/// <example>
/// <para>Provide only an input folder, which will causes ReportUnit to search entire directory for report files.</para>
/// <para>Cake task:</para>
/// <code>
/// ReportUnit("c:/temp");
/// </code>
/// </example>
public void ReportUnit(Cake.Core.IO.DirectoryPath inputFolder)
{
Cake.Common.Tools.ReportUnit.ReportUnitAliases.ReportUnit(Context, inputFolder);
}
/// <summary>
/// Converts the reports in the specified directory into human readable form.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="inputFolder">The input folder.</param>
/// <param name="settings">The ReportUnit settings.</param>
/// <example>
/// <para>Provide an input folder and custom ToolPath, which will causes ReportUnit to search entire directory for report files.</para>
/// <para>Cake task:</para>
/// <code>
/// ReportUnit("c:/temp", new ReportUnitSettings(){
/// ToolPath = "c:/tools/reportunit.exe"
/// });
/// </code>
/// </example>
public void ReportUnit(Cake.Core.IO.DirectoryPath inputFolder, Cake.Common.Tools.ReportUnit.ReportUnitSettings settings)
{
Cake.Common.Tools.ReportUnit.ReportUnitAliases.ReportUnit(Context, inputFolder, settings);
}
/// <summary>
/// Converts the reports in the specified directory into human readable form and outputs to specified folder.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="inputFolder">The input folder.</param>
/// <param name="outputFolder">The output folder.</param>
/// <param name="settings">The ReportUnit settings.</param>
/// <example>
/// <para>Provide both input and output folder, which will causes ReportUnit to search entire directory for report files, and output the results to specified location.</para>
/// <para>Cake task:</para>
/// <code>
/// ReportUnit("c:/temp/input", "c:/temp/output");
/// </code>
/// </example>
public void ReportUnit(Cake.Core.IO.DirectoryPath inputFolder, Cake.Core.IO.DirectoryPath outputFolder, Cake.Common.Tools.ReportUnit.ReportUnitSettings settings)
{
Cake.Common.Tools.ReportUnit.ReportUnitAliases.ReportUnit(Context, inputFolder, outputFolder, settings);
}
/// <summary>
/// Converts the single specified report into human readable form and outputs to specified file.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="inputFile">The input file.</param>
/// <param name="outputFile">The output file.</param>
/// <example>
/// <para>Provide both input and output file, which will causes ReportUnit to transform only the specific file, and output to the specified location.</para>
/// <para>Cake task:</para>
/// <code>
/// ReportUnit("c:/temp/input", "c:/temp/output");
/// </code>
/// </example>
public void ReportUnit(Cake.Core.IO.FilePath inputFile, Cake.Core.IO.FilePath outputFile)
{
Cake.Common.Tools.ReportUnit.ReportUnitAliases.ReportUnit(Context, inputFile, outputFile);
}
/// <summary>
/// Converts the single specified report into human readable form and outputs to specified file.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="inputFile">The input file.</param>
/// <param name="outputFile">The output file.</param>
/// <param name="settings">The ReportUnit settings.</param>
/// <example>
/// <para>Provide both input and output file, which will causes ReportUnit to transform only the specific file, and output to the specified location. Also use a custom path for the reportunit.exe.</para>
/// <para>Cake task:</para>
/// <code>
/// ReportUnit("c:/temp/input", "c:/temp/output", new ReportUnitSettings(){
/// ToolPath = "c:/tools/reportunit.exe"
/// });
/// </code>
/// </example>
public void ReportUnit(Cake.Core.IO.FilePath inputFile, Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.ReportUnit.ReportUnitSettings settings)
{
Cake.Common.Tools.ReportUnit.ReportUnitAliases.ReportUnit(Context, inputFile, outputFile, settings);
}
/// <summary>
/// Converts the coverage report specified by the glob pattern into human readable form.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The glob pattern.</param>
/// <param name="targetDir">The output directory.</param>
/// <example>
/// <code>
/// ReportGenerator("c:/temp/coverage/*.xml", "c:/temp/output");
/// </code>
/// </example>
public void ReportGenerator(System.String pattern, Cake.Core.IO.DirectoryPath targetDir)
{
Cake.Common.Tools.ReportGenerator.ReportGeneratorAliases.ReportGenerator(Context, pattern, targetDir);
}
/// <summary>
/// Converts the coverage report specified by the glob pattern into human readable form using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The glob pattern.</param>
/// <param name="targetDir">The output directory.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// ReportGenerator("c:/temp/coverage/*.xml", "c:/temp/output", new ReportGeneratorSettings(){
/// ToolPath = "c:/tools/reportgenerator.exe"
/// });
/// </code>
/// </example>
public void ReportGenerator(System.String pattern, Cake.Core.IO.DirectoryPath targetDir, Cake.Common.Tools.ReportGenerator.ReportGeneratorSettings settings)
{
Cake.Common.Tools.ReportGenerator.ReportGeneratorAliases.ReportGenerator(Context, pattern, targetDir, settings);
}
/// <summary>
/// Converts the specified coverage report into human readable form.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="report">The coverage report.</param>
/// <param name="targetDir">The output directory.</param>
/// <example>
/// <code>
/// ReportGenerator("c:/temp/coverage/report.xml", "c:/temp/output");
/// </code>
/// </example>
public void ReportGenerator(Cake.Core.IO.FilePath report, Cake.Core.IO.DirectoryPath targetDir)
{
Cake.Common.Tools.ReportGenerator.ReportGeneratorAliases.ReportGenerator(Context, report, targetDir);
}
/// <summary>
/// Converts the specified coverage report into human readable form using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="report">The coverage report.</param>
/// <param name="targetDir">The output directory.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// ReportGenerator("c:/temp/coverage.xml", "c:/temp/output", new ReportGeneratorSettings(){
/// ToolPath = "c:/tools/reportgenerator.exe"
/// });
/// </code>
/// </example>
public void ReportGenerator(Cake.Core.IO.FilePath report, Cake.Core.IO.DirectoryPath targetDir, Cake.Common.Tools.ReportGenerator.ReportGeneratorSettings settings)
{
Cake.Common.Tools.ReportGenerator.ReportGeneratorAliases.ReportGenerator(Context, report, targetDir, settings);
}
/// <summary>
/// Converts the specified coverage reports into human readable form.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="reports">The coverage reports.</param>
/// <param name="targetDir">The output directory.</param>
/// <example>
/// <code>
/// ReportGenerator(new[] { "c:/temp/coverage1.xml", "c:/temp/coverage2.xml" }, "c:/temp/output");
/// </code>
/// </example>
public void ReportGenerator(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> reports, Cake.Core.IO.DirectoryPath targetDir)
{
Cake.Common.Tools.ReportGenerator.ReportGeneratorAliases.ReportGenerator(Context, reports, targetDir);
}
/// <summary>
/// Converts the specified coverage reports into human readable form using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="reports">The coverage reports.</param>
/// <param name="targetDir">The output directory.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// ReportGenerator(new[] { "c:/temp/coverage1.xml", "c:/temp/coverage2.xml" }, "c:/temp/output", new ReportGeneratorSettings(){
/// ToolPath = "c:/tools/reportgenerator.exe"
/// });
/// </code>
/// </example>
public void ReportGenerator(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> reports, Cake.Core.IO.DirectoryPath targetDir, Cake.Common.Tools.ReportGenerator.ReportGeneratorSettings settings)
{
Cake.Common.Tools.ReportGenerator.ReportGeneratorAliases.ReportGenerator(Context, reports, targetDir, settings);
}
/// <summary>
/// Runs <see href="https://github.com/OpenCover/opencover">OpenCover</see>
/// for the specified action and settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="action">The action to run OpenCover for.</param>
/// <param name="outputFile">The OpenCover output file.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// OpenCover(tool =&gt; {
/// tool.XUnit2("./**/App.Tests.dll",
/// new XUnit2Settings {
/// ShadowCopy = false
/// });
/// },
/// new FilePath("./result.xml"),
/// new OpenCoverSettings()
/// .WithFilter("+[App]*")
/// .WithFilter("-[App.Tests]*"));
/// </code>
/// </example>
public void OpenCover(System.Action<Cake.Core.ICakeContext> action, Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.OpenCover.OpenCoverSettings settings)
{
Cake.Common.Tools.OpenCover.OpenCoverAliases.OpenCover(Context, action, outputFile, settings);
}
/// <summary>
/// Compiles the given NSIS script using the default settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="scriptFile">The path to the <c>.nsi</c> script file to compile.</param>
/// <example>
/// <code>
/// MakeNSIS("./src/Cake.nsi");
/// </code>
/// </example>
public void MakeNSIS(Cake.Core.IO.FilePath scriptFile)
{
Cake.Common.Tools.NSIS.NSISAliases.MakeNSIS(Context, scriptFile);
}
/// <summary>
/// Compiles the given NSIS script using the given <paramref name="settings" />.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="scriptFile">The path to the <c>.nsi</c> script file to compile.</param>
/// <param name="settings">The <see cref="T:Cake.Common.Tools.NSIS.MakeNSISSettings" /> to use.</param>
/// <example>
/// <code>
/// MakeNSIS("./src/Cake.nsi", new MakeNSISSettings {
/// NoConfig = true
/// });
/// </code>
/// </example>
public void MakeNSIS(Cake.Core.IO.FilePath scriptFile, Cake.Common.Tools.NSIS.MakeNSISSettings settings)
{
Cake.Common.Tools.NSIS.NSISAliases.MakeNSIS(Context, scriptFile, settings);
}
/// <summary>
/// Runs all MSpec tests in the assemblies matching the specified pattern.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <example>
/// <code>
/// MSpec("./src/**/bin/Release/*.Tests.dll");
/// </code>
/// </example>
public void MSpec(System.String pattern)
{
Cake.Common.Tools.MSpec.MSpecAliases.MSpec(Context, pattern);
}
/// <summary>
/// Runs all MSpec tests in the assemblies matching the specified pattern.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// MSpec("./src/**/bin/Release/*.Tests.dll",
/// new MSpecSettings {
/// Parallelism = ParallelismOption.All,
/// HtmlReport = true,
/// NoAppDomain = true,
/// OutputDirectory = "./build"
/// });
/// </code>
/// </example>
public void MSpec(System.String pattern, Cake.Common.Tools.MSpec.MSpecSettings settings)
{
Cake.Common.Tools.MSpec.MSpecAliases.MSpec(Context, pattern, settings);
}
/// <summary>
/// Runs all MSpec tests in the specified assemblies.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <example>
/// <code>
/// MSpec(new []{
/// "./src/Cake.Common.Tests/bin/Release/Cake.Common.Tests.dll",
/// "./src/Cake.Core.Tests/bin/Release/Cake.Core.Tests.dll",
/// "./src/Cake.NuGet.Tests/bin/Release/Cake.NuGet.Tests.dll",
/// "./src/Cake.Tests/bin/Release/Cake.Tests.dll"
/// });
/// </code>
/// </example>
public void MSpec(System.Collections.Generic.IEnumerable<System.String> assemblies)
{
Cake.Common.Tools.MSpec.MSpecAliases.MSpec(Context, assemblies);
}
/// <summary>
/// Runs all MSpec tests in the specified assemblies.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <example>
/// <code>
/// var testAssemblies = GetFiles("./src/**/bin/Release/*.Tests.dll");
/// MSpec(testAssemblies);
/// </code>
/// </example>
public void MSpec(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblies)
{
Cake.Common.Tools.MSpec.MSpecAliases.MSpec(Context, assemblies);
}
/// <summary>
/// Runs all MSpec tests in the specified assemblies.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// MSpec(new []{
/// "./src/Cake.Common.Tests/bin/Release/Cake.Common.Tests.dll",
/// "./src/Cake.Core.Tests/bin/Release/Cake.Core.Tests.dll",
/// "./src/Cake.NuGet.Tests/bin/Release/Cake.NuGet.Tests.dll",
/// "./src/Cake.Tests/bin/Release/Cake.Tests.dll"
/// },
/// new MSpecSettings {
/// Parallelism = ParallelismOption.All,
/// HtmlReport = true,
/// NoAppDomain = true,
/// OutputDirectory = "./build"
/// });
/// </code>
/// </example>
public void MSpec(System.Collections.Generic.IEnumerable<System.String> assemblies, Cake.Common.Tools.MSpec.MSpecSettings settings)
{
Cake.Common.Tools.MSpec.MSpecAliases.MSpec(Context, assemblies, settings);
}
/// <summary>
/// Runs all MSpec tests in the specified assemblies.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var testAssemblies = GetFiles("./src/**/bin/Release/*.Tests.dll");
/// MSpec(testAssemblies,
/// new MSpecSettings {
/// Parallelism = ParallelismOption.All,
/// HtmlReport = true,
/// NoAppDomain = true,
/// OutputDirectory = "./build"
/// });
/// </code>
/// </example>
public void MSpec(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblies, Cake.Common.Tools.MSpec.MSpecSettings settings)
{
Cake.Common.Tools.MSpec.MSpecAliases.MSpec(Context, assemblies, settings);
}
/// <summary>
/// Analyses the specified solution with Resharper's InspectCode.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="solution">The solution.</param>
/// <example>
/// <code>
/// InspectCode("./src/MySolution.sln");
/// </code>
/// </example>
public void InspectCode(Cake.Core.IO.FilePath solution)
{
Cake.Common.Tools.InspectCode.InspectCodeAliases.InspectCode(Context, solution);
}
/// <summary>
/// Analyses the specified solution with Resharper's InspectCode,
/// using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="solution">The solution.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var buildOutputDirectory = Directory("./.build");
/// var resharperReportsDirectory = buildOutputDirectory + Directory("_ReSharperReports");
///
/// var msBuildProperties = new Dictionary&lt;string, string&gt;();
/// msBuildProperties.Add("configuration", configuration);
/// msBuildProperties.Add("platform", "AnyCPU");
///
/// InspectCode("./MySolution.sln", new InspectCodeSettings {
/// SolutionWideAnalysis = true,
/// Profile = "./MySolution.sln.DotSettings",
/// MsBuildProperties = msBuildProperties,
/// OutputFile = resharperReportsDirectory + File("inspectcode-output.xml"),
/// ThrowExceptionOnFindingViolations = true
/// });
/// </code>
/// </example>
public void InspectCode(Cake.Core.IO.FilePath solution, Cake.Common.Tools.InspectCode.InspectCodeSettings settings)
{
Cake.Common.Tools.InspectCode.InspectCodeAliases.InspectCode(Context, solution, settings);
}
/// <summary>
/// Runs ReSharper's InspectCode using the specified config file.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="configFile">The config file.</param>
/// <example>
/// <code>
/// InspectCodeFromConfig("./src/inspectcode.config");
/// </code>
/// </example>
public void InspectCodeFromConfig(Cake.Core.IO.FilePath configFile)
{
Cake.Common.Tools.InspectCode.InspectCodeAliases.InspectCodeFromConfig(Context, configFile);
}
/// <summary>
/// Compiles the given Inno Setup script using the default settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="scriptFile">The path to the <c>.iss</c> script file to compile.</param>
/// <example>
/// <code>
/// InnoSetup("./src/Cake.iss");
/// </code>
/// </example>
public void InnoSetup(Cake.Core.IO.FilePath scriptFile)
{
Cake.Common.Tools.InnoSetup.InnoSetupAliases.InnoSetup(Context, scriptFile);
}
/// <summary>
/// Compiles the given Inno Setup script using the given <paramref name="settings" />.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="scriptFile">The path to the <c>.iss</c> script file to compile.</param>
/// <param name="settings">The <see cref="T:Cake.Common.Tools.InnoSetup.InnoSetupSettings" /> to use.</param>
/// <example>
/// <code>
/// InnoSetup("./src/Cake.iss", new InnoSetupSettings {
/// OutputDir = outputDirectory
/// });
/// </code>
/// </example>
public void InnoSetup(Cake.Core.IO.FilePath scriptFile, Cake.Common.Tools.InnoSetup.InnoSetupSettings settings)
{
Cake.Common.Tools.InnoSetup.InnoSetupAliases.InnoSetup(Context, scriptFile, settings);
}
/// <summary>
/// Merges the specified assemblies.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="outputFile">The output file.</param>
/// <param name="primaryAssembly">The primary assembly.</param>
/// <param name="assemblyPaths">The assembly paths.</param>
/// <example>
/// <code>
/// var assemblyPaths = GetFiles("./**/Cake.*.dll");
/// ILRepack("./MergedCake.exe", "./Cake.exe", assemblyPaths);
/// </code>
/// </example>
public void ILRepack(Cake.Core.IO.FilePath outputFile, Cake.Core.IO.FilePath primaryAssembly, System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblyPaths)
{
Cake.Common.Tools.ILRepack.ILRepackAliases.ILRepack(Context, outputFile, primaryAssembly, assemblyPaths);
}
/// <summary>
/// Merges the specified assemblies.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="outputFile">The output file.</param>
/// <param name="primaryAssembly">The primary assembly.</param>
/// <param name="assemblyPaths">The assembly paths.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var assemblyPaths = GetFiles("./**/Cake.*.dll");
/// ILRepack(
/// "./MergedCake.exe",
/// "./Cake.exe",
/// assemblyPaths,
/// new ILRepackSettings { Internalize = true });
/// </code>
/// </example>
public void ILRepack(Cake.Core.IO.FilePath outputFile, Cake.Core.IO.FilePath primaryAssembly, System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblyPaths, Cake.Common.Tools.ILRepack.ILRepackSettings settings)
{
Cake.Common.Tools.ILRepack.ILRepackAliases.ILRepack(Context, outputFile, primaryAssembly, assemblyPaths, settings);
}
/// <summary>
/// Retrieves the GitVersion output.
/// </summary>
/// <param name="context">The context.</param>
/// <returns>The git version info.</returns>
/// <example>
/// <para>Update the assembly info files for the project.</para>
/// <para>Cake task:</para>
/// <code>
/// <![CDATA[
/// Task("UpdateAssemblyInfo")
/// .Does(() =>
/// {
/// GitVersion(new GitVersionSettings {
/// UpdateAssemblyInfo = true
/// });
/// });
/// ]]>
/// </code>
/// <para>Get the git version info for the project using a dynamic repository.</para>
/// <para>Cake task:</para>
/// <code>
/// <![CDATA[
/// Task("GetVersionInfo")
/// .Does(() =>
/// {
/// var result = GitVersion(new GitVersionSettings {
/// UserName = "MyUser",
/// Password = "MyPassword,
/// Url = "http://git.myhost.com/myproject.git"
/// Branch = "develop"
/// Commit = EnviromentVariable("MY_COMMIT")
/// });
/// // Use result for building nuget packages, setting build server version, etc...
/// });
/// ]]>
/// </code>
/// </example>
public Cake.Common.Tools.GitVersion.GitVersion GitVersion()
{
return Cake.Common.Tools.GitVersion.GitVersionAliases.GitVersion(Context);
}
/// <summary>
/// Retrieves the GitVersion output.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="settings">The GitVersion settings.</param>
/// <returns>The git version info.</returns>
/// <example>
/// <para>Update the assembly info files for the project.</para>
/// <para>Cake task:</para>
/// <code>
/// <![CDATA[
/// Task("UpdateAssemblyInfo")
/// .Does(() =>
/// {
/// GitVersion(new GitVersionSettings {
/// UpdateAssemblyInfo = true
/// });
/// });
/// ]]>
/// </code>
/// <para>Get the git version info for the project using a dynamic repository.</para>
/// <para>Cake task:</para>
/// <code>
/// <![CDATA[
/// Task("GetVersionInfo")
/// .Does(() =>
/// {
/// var result = GitVersion(new GitVersionSettings {
/// UserName = "MyUser",
/// Password = "MyPassword,
/// Url = "http://git.myhost.com/myproject.git"
/// Branch = "develop"
/// Commit = EnviromentVariable("MY_COMMIT")
/// });
/// // Use result for building nuget packages, setting build server version, etc...
/// });
/// ]]>
/// </code>
/// </example>
public Cake.Common.Tools.GitVersion.GitVersion GitVersion(Cake.Common.Tools.GitVersion.GitVersionSettings settings)
{
return Cake.Common.Tools.GitVersion.GitVersionAliases.GitVersion(Context, settings);
}
/// <summary>
/// Generates a set of release notes based on the commit history of the repository and specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="outputFile">The output file.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// GitReleaseNotes("c:/temp/releasenotes.md", new GitReleaseNotesSettings {
/// WorkingDirectory = "c:/temp",
/// Verbose = true,
/// IssueTracker = IssueTracker.GitHub,
/// AllTags = true,
/// RepoUserName = "bob",
/// RepoPassword = "password",
/// RepoUrl = "http://myrepo.co.uk",
/// RepoBranch = "master",
/// IssueTrackerUrl = "http://myissuetracker.co.uk",
/// IssueTrackerUserName = "bob",
/// IssueTrackerPassword = "password",
/// IssueTrackerProjectId = "1234",
/// Categories = "Category1",
/// Version = "1.2.3.4",
/// AllLabels = true
/// });
/// </code>
/// </example>
public void GitReleaseNotes(Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.GitReleaseNotes.GitReleaseNotesSettings settings)
{
Cake.Common.Tools.GitReleaseNotes.GitReleaseNotesAliases.GitReleaseNotes(Context, outputFile, settings);
}
/// <summary>
/// Creates a Package Release.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="userName">The user name.</param>
/// <param name="password">The password.</param>
/// <param name="owner">The owner.</param>
/// <param name="repository">The repository.</param>
/// <example>
/// <code>
/// GitReleaseManagerCreate("user", "password", "owner", "repo");
/// </code>
/// </example>
/// <example>
/// <code>
/// GitReleaseManagerCreate("user", "password", "owner", "repo");
/// </code>
/// </example>
public void GitReleaseManagerCreate(System.String userName, System.String password, System.String owner, System.String repository)
{
Cake.Common.Tools.GitReleaseManager.GitReleaseManagerAliases.GitReleaseManagerCreate(Context, userName, password, owner, repository);
}
/// <summary>
/// Creates a Package Release using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="userName">The user name.</param>
/// <param name="password">The password.</param>
/// <param name="owner">The owner.</param>
/// <param name="repository">The repository.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// GitReleaseManagerCreate("user", "password", "owner", "repo", new GitReleaseManagerCreateSettings {
/// Milestone = "0.1.0",
/// Prerelease = false,
/// Assets = "c:/temp/asset1.txt,c:/temp/asset2.txt",
/// TargetCommitish = "master",
/// TargetDirectory = "c:/repo",
/// LogFilePath = "c:/temp/grm.log"
/// });
/// </code>
/// </example>
/// <example>
/// <code>
/// GitReleaseManagerCreate("user", "password", "owner", "repo", new GitReleaseManagerCreateSettings {
/// Name = "0.1.0",
/// InputFilePath = "c:/repo/releasenotes.md",
/// Prerelease = false,
/// Assets = "c:/temp/asset1.txt,c:/temp/asset2.txt",
/// TargetCommitish = "master",
/// TargetDirectory = "c:/repo",
/// LogFilePath = "c:/temp/grm.log"
/// });
/// </code>
/// </example>
public void GitReleaseManagerCreate(System.String userName, System.String password, System.String owner, System.String repository, Cake.Common.Tools.GitReleaseManager.Create.GitReleaseManagerCreateSettings settings)
{
Cake.Common.Tools.GitReleaseManager.GitReleaseManagerAliases.GitReleaseManagerCreate(Context, userName, password, owner, repository, settings);
}
/// <summary>
/// Add Assets to an existing release.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="userName">The user name.</param>
/// <param name="password">The password.</param>
/// <param name="owner">The owner.</param>
/// <param name="repository">The repository.</param>
/// <param name="tagName">The tag name.</param>
/// <param name="assets">The assets.</param>
/// <example>
/// <code>
/// GitReleaseManagerAddAssets("user", "password", "owner", "repo", "0.1.0", "c:/temp/asset1.txt,c:/temp/asset2.txt");
/// </code>
/// </example>
public void GitReleaseManagerAddAssets(System.String userName, System.String password, System.String owner, System.String repository, System.String tagName, System.String assets)
{
Cake.Common.Tools.GitReleaseManager.GitReleaseManagerAliases.GitReleaseManagerAddAssets(Context, userName, password, owner, repository, tagName, assets);
}
/// <summary>
/// Add Assets to an existing release using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="userName">The user name.</param>
/// <param name="password">The password.</param>
/// <param name="owner">The owner.</param>
/// <param name="repository">The repository.</param>
/// <param name="tagName">The tag name.</param>
/// <param name="assets">The assets.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// GitReleaseManagerAddAssets("user", "password", "owner", "repo", "0.1.0", "c:/temp/asset1.txt,c:/temp/asset2.txt" new GitReleaseManagerAddAssetsSettings {
/// TargetDirectory = "c:/repo",
/// LogFilePath = "c:/temp/grm.log"
/// });
/// </code>
/// </example>
public void GitReleaseManagerAddAssets(System.String userName, System.String password, System.String owner, System.String repository, System.String tagName, System.String assets, Cake.Common.Tools.GitReleaseManager.AddAssets.GitReleaseManagerAddAssetsSettings settings)
{
Cake.Common.Tools.GitReleaseManager.GitReleaseManagerAliases.GitReleaseManagerAddAssets(Context, userName, password, owner, repository, tagName, assets, settings);
}
/// <summary>
/// Closes the milestone associated with a release.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="userName">The user name.</param>
/// <param name="password">The password.</param>
/// <param name="owner">The owner.</param>
/// <param name="repository">The repository.</param>
/// <param name="milestone">The milestone.</param>
/// <example>
/// <code>
/// GitReleaseManagerClose("user", "password", "owner", "repo", "0.1.0");
/// </code>
/// </example>
public void GitReleaseManagerClose(System.String userName, System.String password, System.String owner, System.String repository, System.String milestone)
{
Cake.Common.Tools.GitReleaseManager.GitReleaseManagerAliases.GitReleaseManagerClose(Context, userName, password, owner, repository, milestone);
}
/// <summary>
/// Closes the milestone associated with a release using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="userName">The user name.</param>
/// <param name="password">The password.</param>
/// <param name="owner">The owner.</param>
/// <param name="repository">The repository.</param>
/// <param name="milestone">The milestone.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// GitReleaseManagerClose("user", "password", "owner", "repo", "0.1.0", new GitReleaseManagerCloseMilestoneSettings {
/// TargetDirectory = "c:/repo",
/// LogFilePath = "c:/temp/grm.log"
/// });
/// </code>
/// </example>
public void GitReleaseManagerClose(System.String userName, System.String password, System.String owner, System.String repository, System.String milestone, Cake.Common.Tools.GitReleaseManager.Close.GitReleaseManagerCloseMilestoneSettings settings)
{
Cake.Common.Tools.GitReleaseManager.GitReleaseManagerAliases.GitReleaseManagerClose(Context, userName, password, owner, repository, milestone, settings);
}
/// <summary>
/// Publishes the release.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="userName">The user name.</param>
/// <param name="password">The password.</param>
/// <param name="owner">The owner.</param>
/// <param name="repository">The repository.</param>
/// <param name="tagName">The tag name.</param>
/// <example>
/// <code>
/// GitReleaseManagerPublish("user", "password", "owner", "repo", "0.1.0");
/// </code>
/// </example>
public void GitReleaseManagerPublish(System.String userName, System.String password, System.String owner, System.String repository, System.String tagName)
{
Cake.Common.Tools.GitReleaseManager.GitReleaseManagerAliases.GitReleaseManagerPublish(Context, userName, password, owner, repository, tagName);
}
/// <summary>
/// Publishes the release using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="userName">The user name.</param>
/// <param name="password">The password.</param>
/// <param name="owner">The owner.</param>
/// <param name="repository">The repository.</param>
/// <param name="tagName">The tag name.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// GitReleaseManagerPublish("user", "password", "owner", "repo", "0.1.0", new GitReleaseManagerPublishSettings {
/// TargetDirectory = "c:/repo",
/// LogFilePath = "c:/temp/grm.log"
/// });
/// </code>
/// </example>
public void GitReleaseManagerPublish(System.String userName, System.String password, System.String owner, System.String repository, System.String tagName, Cake.Common.Tools.GitReleaseManager.Publish.GitReleaseManagerPublishSettings settings)
{
Cake.Common.Tools.GitReleaseManager.GitReleaseManagerAliases.GitReleaseManagerPublish(Context, userName, password, owner, repository, tagName, settings);
}
/// <summary>
/// Exports the release notes.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="userName">The user name.</param>
/// <param name="password">The password.</param>
/// <param name="owner">The owner.</param>
/// <param name="repository">The repository.</param>
/// <param name="fileOutputPath">The output file path.</param>
/// <example>
/// <code>
/// GitReleaseManagerExport("user", "password", "owner", "repo", "c:/temp/releasenotes.md")
/// });
/// </code>
/// </example>
public void GitReleaseManagerExport(System.String userName, System.String password, System.String owner, System.String repository, Cake.Core.IO.FilePath fileOutputPath)
{
Cake.Common.Tools.GitReleaseManager.GitReleaseManagerAliases.GitReleaseManagerExport(Context, userName, password, owner, repository, fileOutputPath);
}
/// <summary>
/// Exports the release notes using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="userName">The user name.</param>
/// <param name="password">The password.</param>
/// <param name="owner">The owner.</param>
/// <param name="repository">The repository.</param>
/// <param name="fileOutputPath">The output file path.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// GitReleaseManagerExport("user", "password", "owner", "repo", "c:/temp/releasenotes.md", new GitReleaseManagerExportSettings {
/// TagName = "0.1.0",
/// TargetDirectory = "c:/repo",
/// LogFilePath = "c:/temp/grm.log"
/// });
/// </code>
/// </example>
public void GitReleaseManagerExport(System.String userName, System.String password, System.String owner, System.String repository, Cake.Core.IO.FilePath fileOutputPath, Cake.Common.Tools.GitReleaseManager.Export.GitReleaseManagerExportSettings settings)
{
Cake.Common.Tools.GitReleaseManager.GitReleaseManagerAliases.GitReleaseManagerExport(Context, userName, password, owner, repository, fileOutputPath, settings);
}
/// <summary>
/// Update the pdb file to link all sources.
/// This will allow anyone to step through the source code while debugging without a symbol source server.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="pdbFilePath">The PDB File to analyze.</param>
/// <example>
/// <code>
/// GitLink3("C:/temp/solution/bin/my.pdb");
/// </code>
/// </example>
public void GitLink3(Cake.Core.IO.FilePath pdbFilePath)
{
Cake.Common.Tools.GitLink.GitLink3Aliases.GitLink3(Context, pdbFilePath);
}
/// <summary>
/// Update the pdb file to link all sources.
/// This will allow anyone to step through the source code while debugging without a symbol source server.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="pdbFilePath">The PDB File to analyze.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// GitLink3("C:/temp/solution/bin/my.pdb", new GitLink3Settings {
/// RepositoryUrl = "http://mydomain.com",
/// ShaHash = "abcdef"
/// });
/// </code>
/// </example>
public void GitLink3(Cake.Core.IO.FilePath pdbFilePath, Cake.Common.Tools.GitLink.GitLink3Settings settings)
{
Cake.Common.Tools.GitLink.GitLink3Aliases.GitLink3(Context, pdbFilePath, settings);
}
/// <summary>
/// Update the pdb files to link all sources.
/// This will allow anyone to step through the source code while debugging without a symbol source server.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="pdbFiles">The PDB File collection to analyze.</param>
/// <example>
/// <code>
/// GitLink3("C:/temp/solution/bin/**/*.pdb");
/// </code>
/// </example>
public void GitLink3(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> pdbFiles)
{
Cake.Common.Tools.GitLink.GitLink3Aliases.GitLink3(Context, pdbFiles);
}
/// <summary>
/// Update the pdb files to link all sources.
/// This will allow anyone to step through the source code while debugging without a symbol source server.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="pdbFiles">The PDB File collection to analyze.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// GitLink3("C:/temp/solution/bin/**/*.pdb", new GitLink3Settings {
/// RepositoryUrl = "http://mydomain.com",
/// ShaHash = "abcdef"
/// });
/// </code>
/// </example>
public void GitLink3(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> pdbFiles, Cake.Common.Tools.GitLink.GitLink3Settings settings)
{
Cake.Common.Tools.GitLink.GitLink3Aliases.GitLink3(Context, pdbFiles, settings);
}
/// <summary>
/// Update pdb files to link all sources.
/// This will allow anyone to step through the source code while debugging without a symbol source server.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="repositoryRootPath">The Solution File to analyze.</param>
/// <example>
/// <code>
/// GitLink("C:/temp/solution");
/// </code>
/// </example>
public void GitLink(Cake.Core.IO.DirectoryPath repositoryRootPath)
{
Cake.Common.Tools.GitLink.GitLinkAliases.GitLink(Context, repositoryRootPath);
}
/// <summary>
/// Update pdb files to link all sources, using specified settings.
/// This will allow anyone to step through the source code while debugging without a symbol source server.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="repositoryRootPath">The path to the Root of the Repository to analyze.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// GitLink("C:/temp/solution", new GitLinkSettings {
/// RepositoryUrl = "http://mydomain.com",
/// Branch = "master",
/// ShaHash = "abcdef",
/// });
/// </code>
/// </example>
public void GitLink(Cake.Core.IO.DirectoryPath repositoryRootPath, Cake.Common.Tools.GitLink.GitLinkSettings settings)
{
Cake.Common.Tools.GitLink.GitLinkAliases.GitLink(Context, repositoryRootPath, settings);
}
/// <summary>
/// Runs all Fixie tests in the assemblies matching the specified pattern.
/// </summary>
/// <example>
/// <code>
/// Fixie("./src/UnitTests/*.dll");
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
public void Fixie(System.String pattern)
{
Cake.Common.Tools.Fixie.FixieAliases.Fixie(Context, pattern);
}
/// <summary>
/// Runs all Fixie tests in the assemblies matching the specified pattern,
/// using the specified settings.
/// </summary>
/// <example>
/// <code>
/// Fixie("./src/UnitTests/*.dll", new FixieSettings {
/// NUnitXml = TestResult.xml
/// });
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="settings">The settings.</param>
public void Fixie(System.String pattern, Cake.Common.Tools.Fixie.FixieSettings settings)
{
Cake.Common.Tools.Fixie.FixieAliases.Fixie(Context, pattern, settings);
}
/// <summary>
/// Runs all Fixie tests in the specified assemblies.
/// </summary>
/// <example>
/// <code>
/// var assemblies = new [] {
/// "UnitTests1.dll",
/// "UnitTests2.dll"
/// };
/// Fixie(assemblies);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
public void Fixie(System.Collections.Generic.IEnumerable<System.String> assemblies)
{
Cake.Common.Tools.Fixie.FixieAliases.Fixie(Context, assemblies);
}
/// <summary>
/// Runs all Fixie tests in the specified assemblies.
/// </summary>
/// <example>
/// <code>
/// var assemblies = GetFiles("./src/UnitTests/*.dll");
/// Fixie(assemblies);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
public void Fixie(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblies)
{
Cake.Common.Tools.Fixie.FixieAliases.Fixie(Context, assemblies);
}
/// <summary>
/// Runs all Fixie tests in the specified assemblies,
/// using the specified settings.
/// </summary>
/// <example>
/// <code>
/// var assemblies = new [] {
/// "UnitTests1.dll",
/// "UnitTests2.dll"
/// };
/// Fixie(assemblies, new FixieSettings {
/// NUnitXml = TestResult.xml
/// });
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <param name="settings">The settings.</param>
public void Fixie(System.Collections.Generic.IEnumerable<System.String> assemblies, Cake.Common.Tools.Fixie.FixieSettings settings)
{
Cake.Common.Tools.Fixie.FixieAliases.Fixie(Context, assemblies, settings);
}
/// <summary>
/// Runs all Fixie tests in the specified assemblies,
/// using the specified settings.
/// </summary>
/// <example>
/// <code>
/// var assemblies = GetFiles("./src/UnitTests/*.dll");
/// Fixie(assemblies, new FixieSettings {
/// NUnitXml = TestResult.xml
/// });
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <param name="settings">The settings.</param>
public void Fixie(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblies, Cake.Common.Tools.Fixie.FixieSettings settings)
{
Cake.Common.Tools.Fixie.FixieAliases.Fixie(Context, assemblies, settings);
}
/// <summary>
/// Analyses the specified file with ReSharper's DupFinder.
/// The file can either be a solution/project or a source file.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="file">The file to analyze.</param>
/// <example>
/// <code>
/// DupFinder("./src/MySolution.sln");
/// </code>
/// </example>
public void DupFinder(Cake.Core.IO.FilePath file)
{
Cake.Common.Tools.DupFinder.DupFinderAliases.DupFinder(Context, file);
}
/// <summary>
/// Analyses the specified file with ReSharper's DupFinder using the specified settings.
/// The file can either be a solution/project or a source file.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="file">The file to analyze.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var buildOutputDirectory = Directory("./.build");
/// var resharperReportsDirectory = buildOutputDirectory + Directory("_ReSharperReports");
/// var rootDirectoryPath = MakeAbsolute(Context.Environment.WorkingDirectory);
///
/// DupFinder("./src/MySolution.sln", new DupFinderSettings {
/// ShowStats = true,
/// ShowText = true,
/// ExcludePattern = new String[]
/// {
/// rootDirectoryPath + "/**/*Designer.cs",
/// },
/// OutputFile = resharperReportsDirectory + File("dupfinder-output.xml"),
/// ThrowExceptionOnFindingDuplicates = true
/// });
/// </code>
/// </example>
public void DupFinder(Cake.Core.IO.FilePath file, Cake.Common.Tools.DupFinder.DupFinderSettings settings)
{
Cake.Common.Tools.DupFinder.DupFinderAliases.DupFinder(Context, file, settings);
}
/// <summary>
/// Analyses the specified projects with ReSharper's DupFinder.
/// The files can either be solutions and projects or a source files.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="files">The files to analyze.</param>
/// <example>
/// <code>
/// var projects = GetFiles("./src/**/*.csproj");
/// DupFinder(projects);
/// </code>
/// </example>
public void DupFinder(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> files)
{
Cake.Common.Tools.DupFinder.DupFinderAliases.DupFinder(Context, files);
}
/// <summary>
/// Analyses the specified projects with ReSharper's DupFinder using the specified settings.
/// The files can either be solutions and projects or a source files.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="files">The files to analyze.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var buildOutputDirectory = Directory("./.build");
/// var resharperReportsDirectory = buildOutputDirectory + Directory("_ReSharperReports");
/// var rootDirectoryPath = MakeAbsolute(Context.Environment.WorkingDirectory);
///
/// var projects = GetFiles("./src/**/*.csproj");
/// DupFinder(projects, new DupFinderSettings {
/// ShowStats = true,
/// ShowText = true,
/// ExcludePattern = new String[]
/// {
/// rootDirectoryPath + "/**/*Designer.cs",
/// },
/// OutputFile = resharperReportsDirectory + File("dupfinder-output.xml"),
/// ThrowExceptionOnFindingDuplicates = true
/// });
/// </code>
/// </example>
public void DupFinder(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> files, Cake.Common.Tools.DupFinder.DupFinderSettings settings)
{
Cake.Common.Tools.DupFinder.DupFinderAliases.DupFinder(Context, files, settings);
}
/// <summary>
/// Analyses all files matching the specified pattern with ReSharper's DupFinder.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <example>
/// <code>
/// DupFinder("*.cs");
/// </code>
/// </example>
public void DupFinder(System.String pattern)
{
Cake.Common.Tools.DupFinder.DupFinderAliases.DupFinder(Context, pattern);
}
/// <summary>
/// Analyses all files matching the specified pattern with ReSharper's DupFinder,
/// using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var buildOutputDirectory = Directory("./.build");
/// var resharperReportsDirectory = buildOutputDirectory + Directory("_ReSharperReports");
///
/// DupFinder("*.cs", new DupFinderSettings {
/// OutputFile = resharperReportsDirectory + File("dupfinder-output.xml"),
/// });
/// </code>
/// </example>
public void DupFinder(System.String pattern, Cake.Common.Tools.DupFinder.DupFinderSettings settings)
{
Cake.Common.Tools.DupFinder.DupFinderAliases.DupFinder(Context, pattern, settings);
}
/// <summary>
/// Runs ReSharper's DupFinder using the provided config file.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="configFile">The config file.</param>
/// <example>
/// <code>
/// DupFinderFromConfig("./src/dupfinder.config");
/// </code>
/// </example>
public void DupFinderFromConfig(Cake.Core.IO.FilePath configFile)
{
Cake.Common.Tools.DupFinder.DupFinderAliases.DupFinderFromConfig(Context, configFile);
}
/// <summary>
/// Execute an assembly.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="assemblyPath">The assembly path.</param>
/// <example>
/// <code>
/// DotNetCoreExecute("./bin/Debug/app.dll");
/// </code>
/// </example>
public void DotNetCoreExecute(Cake.Core.IO.FilePath assemblyPath)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreExecute(Context, assemblyPath);
}
/// <summary>
/// Execute an assembly with arguments in the specific path.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="assemblyPath">The assembly path.</param>
/// <param name="arguments">The arguments.</param>
/// <example>
/// <code>
/// DotNetCoreExecute("./bin/Debug/app.dll", "--arg");
/// </code>
/// </example>
public void DotNetCoreExecute(Cake.Core.IO.FilePath assemblyPath, Cake.Core.IO.ProcessArgumentBuilder arguments)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreExecute(Context, assemblyPath, arguments);
}
/// <summary>
/// Execute an assembly with arguments in the specific path with settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="assemblyPath">The assembly path.</param>
/// <param name="arguments">The arguments.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var settings = new DotNetCoreExecuteSettings
/// {
/// FrameworkVersion = "1.0.3"
/// };
///
/// DotNetCoreExecute("./bin/Debug/app.dll", "--arg", settings);
/// </code>
/// </example>
public void DotNetCoreExecute(Cake.Core.IO.FilePath assemblyPath, Cake.Core.IO.ProcessArgumentBuilder arguments, Cake.Common.Tools.DotNetCore.Execute.DotNetCoreExecuteSettings settings)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreExecute(Context, assemblyPath, arguments, settings);
}
/// <summary>
/// Restore all NuGet Packages.
/// </summary>
/// <param name="context">The context.</param>
/// <example>
/// <code>
/// DotNetCoreRestore();
/// </code>
/// </example>
public void DotNetCoreRestore()
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreRestore(Context);
}
/// <summary>
/// Restore all NuGet Packages in the specified path.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="root">List of projects and project folders to restore. Each value can be: a path to a project.json or global.json file, or a folder to recursively search for project.json files.</param>
/// <example>
/// <code>
/// DotNetCoreRestore("./src/*");
/// </code>
/// </example>
public void DotNetCoreRestore(System.String root)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreRestore(Context, root);
}
/// <summary>
/// Restore all NuGet Packages with the settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var settings = new DotNetCoreRestoreSettings
/// {
/// Sources = new[] {"https://www.example.com/nugetfeed", "https://www.example.com/nugetfeed2"},
/// FallbackSources = new[] {"https://www.example.com/fallbacknugetfeed"},
/// PackagesDirectory = "./packages",
/// Verbosity = Information,
/// DisableParallel = true,
/// InferRuntimes = new[] {"runtime1", "runtime2"}
/// };
///
/// DotNetCoreRestore(settings);
/// </code>
/// </example>
public void DotNetCoreRestore(Cake.Common.Tools.DotNetCore.Restore.DotNetCoreRestoreSettings settings)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreRestore(Context, settings);
}
/// <summary>
/// Restore all NuGet Packages in the specified path with settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="root">List of projects and project folders to restore. Each value can be: a path to a project.json or global.json file, or a folder to recursively search for project.json files.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var settings = new DotNetCoreRestoreSettings
/// {
/// Sources = new[] {"https://www.example.com/nugetfeed", "https://www.example.com/nugetfeed2"},
/// FallbackSources = new[] {"https://www.example.com/fallbacknugetfeed"},
/// PackagesDirectory = "./packages",
/// Verbosity = Information,
/// DisableParallel = true,
/// InferRuntimes = new[] {"runtime1", "runtime2"}
/// };
///
/// DotNetCoreRestore("./src/*", settings);
/// </code>
/// </example>
public void DotNetCoreRestore(System.String root, Cake.Common.Tools.DotNetCore.Restore.DotNetCoreRestoreSettings settings)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreRestore(Context, root, settings);
}
/// <summary>
/// Build all projects.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="project">The projects path.</param>
/// <example>
/// <code>
/// DotNetCoreBuild("./src/*");
/// </code>
/// </example>
public void DotNetCoreBuild(System.String project)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreBuild(Context, project);
}
/// <summary>
/// Build all projects.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="project">The projects path.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var settings = new DotNetCoreBuildSettings
/// {
/// Framework = "netcoreapp2.0",
/// Configuration = "Debug",
/// OutputDirectory = "./artifacts/"
/// };
///
/// DotNetCoreBuild("./src/*", settings);
/// </code>
/// </example>
public void DotNetCoreBuild(System.String project, Cake.Common.Tools.DotNetCore.Build.DotNetCoreBuildSettings settings)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreBuild(Context, project, settings);
}
/// <summary>
/// Package all projects.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="project">The projects path.</param>
/// <example>
/// <code>
/// DotNetCorePack("./src/*");
/// </code>
/// </example>
public void DotNetCorePack(System.String project)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCorePack(Context, project);
}
/// <summary>
/// Package all projects.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="project">The projects path.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var settings = new DotNetCorePackSettings
/// {
/// Configuration = "Release",
/// OutputDirectory = "./artifacts/"
/// };
///
/// DotNetCorePack("./src/*", settings);
/// </code>
/// </example>
public void DotNetCorePack(System.String project, Cake.Common.Tools.DotNetCore.Pack.DotNetCorePackSettings settings)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCorePack(Context, project, settings);
}
/// <summary>
/// Run all projects.
/// </summary>
/// <param name="context">The context.</param>
/// <example>
/// <code>
/// DotNetCoreRun();
/// </code>
/// </example>
public void DotNetCoreRun()
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreRun(Context);
}
/// <summary>
/// Run project.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="project">The project path.</param>
/// <example>
/// <code>
/// DotNetCoreRun("./src/Project");
/// </code>
/// </example>
public void DotNetCoreRun(System.String project)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreRun(Context, project);
}
/// <summary>
/// Run project with path and arguments.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="project">The project path.</param>
/// <param name="arguments">The arguments.</param>
/// <example>
/// <code>
/// DotNetCoreRun("./src/Project", "--args");
/// </code>
/// </example>
public void DotNetCoreRun(System.String project, Cake.Core.IO.ProcessArgumentBuilder arguments)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreRun(Context, project, arguments);
}
/// <summary>
/// Run project with settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="project">The project path.</param>
/// <param name="arguments">The arguments.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var settings = new DotNetCoreRunSettings
/// {
/// Framework = "netcoreapp2.0",
/// Configuration = "Release"
/// };
///
/// DotNetCoreRun("./src/Project", "--args", settings);
/// </code>
/// </example>
public void DotNetCoreRun(System.String project, Cake.Core.IO.ProcessArgumentBuilder arguments, Cake.Common.Tools.DotNetCore.Run.DotNetCoreRunSettings settings)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreRun(Context, project, arguments, settings);
}
/// <summary>
/// Publish all projects.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="project">The projects path.</param>
/// <example>
/// <code>
/// DotNetCorePublish("./src/*");
/// </code>
/// </example>
public void DotNetCorePublish(System.String project)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCorePublish(Context, project);
}
/// <summary>
/// Publish all projects.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="project">The projects path.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var settings = new DotNetCorePublishSettings
/// {
/// Framework = "netcoreapp2.0",
/// Configuration = "Release",
/// OutputDirectory = "./artifacts/"
/// };
///
/// DotNetCorePublish("./src/*", settings);
/// </code>
/// </example>
public void DotNetCorePublish(System.String project, Cake.Common.Tools.DotNetCore.Publish.DotNetCorePublishSettings settings)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCorePublish(Context, project, settings);
}
/// <summary>
/// Test project.
/// </summary>
/// <param name="context">The context.</param>
/// <example>
/// <code>
/// DotNetCoreTest();
/// </code>
/// </example>
public void DotNetCoreTest()
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreTest(Context);
}
/// <summary>
/// Test project with path.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="project">The project path.</param>
/// <example>
/// <para>Specify the path to the .csproj file in the test project</para>
/// <code>
/// DotNetCoreTest("./test/Project.Tests/Project.Tests.csproj");
/// </code>
/// <para>You could also specify a task that runs multiple test projects.</para>
/// <para>Cake task:</para>
/// <code>
/// Task("Test")
/// .Does(() =&gt;
/// {
/// var projectFiles = GetFiles("./test/**/*.csproj");
/// foreach(var file in projectFiles)
/// {
/// DotNetCoreTest(file.FullPath);
/// }
/// });
/// </code>
/// <para>If your test project is using project.json, the project parameter should just be the directory path.</para>
/// <code>
/// DotNetCoreTest("./test/Project.Tests/");
/// </code>
/// </example>
public void DotNetCoreTest(System.String project)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreTest(Context, project);
}
/// <summary>
/// Test project with settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="project">The project path.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var settings = new DotNetCoreTestSettings
/// {
/// Configuration = "Release"
/// };
///
/// DotNetCoreTest("./test/Project.Tests/Project.Tests.csproj", settings);
/// </code>
/// <para>You could also specify a task that runs multiple test projects.</para>
/// <para>Cake task:</para>
/// <code>
/// Task("Test")
/// .Does(() =&gt;
/// {
/// var settings = new DotNetCoreTestSettings
/// {
/// Configuration = "Release"
/// };
///
/// var projectFiles = GetFiles("./test/**/*.csproj");
/// foreach(var file in projectFiles)
/// {
/// DotNetCoreTest(file.FullPath, settings);
/// }
/// });
/// </code>
/// <para>If your test project is using project.json, the project parameter should just be the directory path.</para>
/// <code>
/// var settings = new DotNetCoreTestSettings
/// {
/// Configuration = "Release"
/// };
///
/// DotNetCoreTest("./test/Project.Tests/", settings);
/// </code>
/// </example>
public void DotNetCoreTest(System.String project, Cake.Common.Tools.DotNetCore.Test.DotNetCoreTestSettings settings)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreTest(Context, project, settings);
}
/// <summary>
/// Cleans a project's output.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="project">The project's path.</param>
/// <example>
/// <code>
/// DotNetCoreClean("./src/project");
/// </code>
/// </example>
public void DotNetCoreClean(System.String project)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreClean(Context, project);
}
/// <summary>
/// Cleans a project's output.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="project">The projects path.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var settings = new DotNetCoreCleanSettings
/// {
/// Framework = "netcoreapp2.0",
/// Configuration = "Debug",
/// OutputDirectory = "./artifacts/"
/// };
///
/// DotNetCoreClean("./src/project", settings);
/// </code>
/// </example>
public void DotNetCoreClean(System.String project, Cake.Common.Tools.DotNetCore.Clean.DotNetCoreCleanSettings settings)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreClean(Context, project, settings);
}
/// <summary>
/// Delete a NuGet Package from a server.
/// </summary>
/// <param name="context">The context.</param>
/// <example>
/// <code>
/// DotNetCoreNuGetDelete();
/// </code>
/// </example>
public void DotNetCoreNuGetDelete()
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreNuGetDelete(Context);
}
/// <summary>
/// Deletes a package from the NuGet.org.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageName">Name of package to delete.</param>
/// <example>
/// <code>
/// DotNetCoreNuGetDelete("Microsoft.AspNetCore.Mvc");
/// </code>
/// </example>
public void DotNetCoreNuGetDelete(System.String packageName)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreNuGetDelete(Context, packageName);
}
/// <summary>
/// Deletes a specific version of a package from the NuGet.org.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageName">Name of package to delete.</param>
/// <param name="packageVersion">Version of package to delete.</param>
/// <example>
/// <code>
/// DotNetCoreRestore("Microsoft.AspNetCore.Mvc", "1.0");
/// </code>
/// </example>
public void DotNetCoreNuGetDelete(System.String packageName, System.String packageVersion)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreNuGetDelete(Context, packageName, packageVersion);
}
/// <summary>
/// Deletes a package from a server
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageName">Name of package to delete.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var settings = new DotNetCoreNuGetDeleteSettings
/// {
/// Source = "https://www.example.com/nugetfeed",
/// NonInteractive = true
/// };
///
/// DotNetCoreNuGetDelete("Microsoft.AspNetCore.Mvc", settings);
/// </code>
/// </example>
public void DotNetCoreNuGetDelete(System.String packageName, Cake.Common.Tools.DotNetCore.NuGet.Delete.DotNetCoreNuGetDeleteSettings settings)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreNuGetDelete(Context, packageName, settings);
}
/// <summary>
/// Deletes a package from a server using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var settings = new DotNetCoreNuGetDeleteSettings
/// {
/// Source = "https://www.example.com/nugetfeed",
/// NonInteractive = true
/// };
///
/// DotNetCoreNuGetDelete(settings);
/// </code>
/// </example>
public void DotNetCoreNuGetDelete(Cake.Common.Tools.DotNetCore.NuGet.Delete.DotNetCoreNuGetDeleteSettings settings)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreNuGetDelete(Context, settings);
}
/// <summary>
/// Deletes a package from a server using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageName">Name of package to delete.</param>
/// <param name="packageVersion">Version of package to delete.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var settings = new DotNetCoreNuGetDeleteSettings
/// {
/// Source = "https://www.example.com/nugetfeed",
/// NonInteractive = true
/// };
///
/// DotNetCoreNuGetDelete("Microsoft.AspNetCore.Mvc", "1.0", settings);
/// </code>
/// </example>
public void DotNetCoreNuGetDelete(System.String packageName, System.String packageVersion, Cake.Common.Tools.DotNetCore.NuGet.Delete.DotNetCoreNuGetDeleteSettings settings)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreNuGetDelete(Context, packageName, packageVersion, settings);
}
/// <summary>
/// Pushes one or more packages to a server.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageName">Name of package to push.</param>
/// <example>
/// <code>
/// DotNetCoreNuGetPush("*.nupkg");
/// </code>
/// </example>
public void DotNetCoreNuGetPush(System.String packageName)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreNuGetPush(Context, packageName);
}
/// <summary>
/// Pushes one or more packages to a server using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageName">Name of package to push.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var settings = new DotNetCoreNuGetPushSettings
/// {
/// Source = "https://www.example.com/nugetfeed",
/// ApiKey = "4003d786-cc37-4004-bfdf-c4f3e8ef9b3a"
/// };
///
/// DotNetCoreNuGetPush("foo*.nupkg", settings);
/// </code>
/// </example>
public void DotNetCoreNuGetPush(System.String packageName, Cake.Common.Tools.DotNetCore.NuGet.Push.DotNetCoreNuGetPushSettings settings)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreNuGetPush(Context, packageName, settings);
}
/// <summary>
/// Builds the specified targets in a project file found in the current working directory.
/// </summary>
/// <param name="context">The context.</param>
/// <example>
/// <code>
/// DotNetCoreMSBuild();
/// </code>
/// </example>
public void DotNetCoreMSBuild()
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreMSBuild(Context);
}
/// <summary>
/// Builds the specified targets in the project file.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="projectOrDirectory">Project file or directory to search for project file.</param>
/// <example>
/// <code>
/// DotNetCoreMSBuild("foobar.proj");
/// </code>
/// </example>
/// <remarks>
/// If a directory is specified, MSBuild searches that directory for a project file.
/// </remarks>
public void DotNetCoreMSBuild(System.String projectOrDirectory)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreMSBuild(Context, projectOrDirectory);
}
/// <summary>
/// Builds the specified targets in a project file found in the current working directory.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var settings = new DotNetCoreMSBuildSettings
/// {
/// NoLogo = true,
/// MaxCpuCount = -1
/// };
///
/// DotNetCoreMSBuild(settings);
/// </code>
/// </example>
public void DotNetCoreMSBuild(Cake.Common.Tools.DotNetCore.MSBuild.DotNetCoreMSBuildSettings settings)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreMSBuild(Context, settings);
}
/// <summary>
/// Builds the specified targets in the project file.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="projectOrDirectory">Project file or directory to search for project file.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var settings = new DotNetCoreMSBuildSettings
/// {
/// NoLogo = true,
/// MaxCpuCount = -1
/// };
///
/// DotNetCoreMSBuild("foobar.proj", settings);
/// </code>
/// </example>
/// <remarks>
/// If a project file is not specified, MSBuild searches the current working directory for a file that has a file
/// extension that ends in "proj" and uses that file. If a directory is specified, MSBuild searches that directory for a project file.
/// </remarks>
public void DotNetCoreMSBuild(System.String projectOrDirectory, Cake.Common.Tools.DotNetCore.MSBuild.DotNetCoreMSBuildSettings settings)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreMSBuild(Context, projectOrDirectory, settings);
}
/// <summary>
/// Test one or more projects specified by a path or glob pattern using the VS Test host runner.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="testFile">A path to the test file or glob for one or more test files.</param>
/// <example>
/// <para>Specify the path to the .csproj file in the test project</para>
/// <code>
/// DotNetCoreTest("./test/Project.Tests/Project.Tests.csproj");
/// </code>
/// <para>You could also specify a glob pattern to run multiple test projects.</para>
/// <code>
/// DotNetCoreTest("./**/*.Tests.csproj");
/// </code>
/// </example>
public void DotNetCoreVSTest(System.String testFile)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreVSTest(Context, testFile);
}
/// <summary>
/// Test one or more projects specified by a path or glob pattern with settings using the VS Test host runner.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="testFile">A path to the test file or glob for one or more test files.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <para>Specify the path to the .csproj file in the test project</para>
/// <code>
/// var settings = new DotNetCoreTestSettings
/// {
/// Framework = "FrameworkCore10",
/// Platform = "x64"
/// };
///
/// DotNetCoreTest("./test/Project.Tests/Project.Tests.csproj", settings);
/// </code>
/// <para>You could also specify a glob pattern to run multiple test projects.</para>
/// <code>
/// var settings = new DotNetCoreTestSettings
/// {
/// Framework = "FrameworkCore10",
/// Platform = "x64",
/// Parallel = true
/// };
///
/// DotNetCoreTest("./**/*.Tests.csproj", settings);
/// </code>
/// </example>
public void DotNetCoreVSTest(System.String testFile, Cake.Common.Tools.DotNetCore.VSTest.DotNetCoreVSTestSettings settings)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreVSTest(Context, testFile, settings);
}
/// <summary>
/// Test one or more specified projects with settings using the VS Test host runner.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="testFiles">The project paths to test.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var settings = new DotNetCoreTestSettings
/// {
/// Framework = "FrameworkCore10",
/// Platform = "x64"
/// };
///
/// DotNetCoreTest(new[] { (FilePath)"./Test/Cake.Common.Tests.csproj" }, settings);
/// </code>
/// <para>You could also specify a task that runs multiple test projects.</para>
/// <para>Cake task:</para>
/// <code>
/// Task("Test")
/// .Does(() =&gt;
/// {
/// var settings = new DotNetCoreTestSettings
/// {
/// Framework = "FrameworkCore10",
/// Platform = "x64",
/// Parallel = true
/// };
///
/// var projectFiles = GetFiles("./test/**/*.csproj");
///
/// DotNetCoreTest(projectFiles, settings);
/// });
/// </code>
/// </example>
public void DotNetCoreVSTest(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> testFiles, Cake.Common.Tools.DotNetCore.VSTest.DotNetCoreVSTestSettings settings)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreVSTest(Context, testFiles, settings);
}
/// <summary>
/// /// Execute an .NET Core Extensibility Tool.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="projectPath">The project path.</param>
/// <param name="command">The command to execute.</param>
/// <example>
/// <code>
/// DotNetCoreTool("./src/project", "xunit", "-xml report.xml");
/// </code>
/// </example>
public void DotNetCoreTool(Cake.Core.IO.FilePath projectPath, System.String command)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreTool(Context, projectPath, command);
}
/// <summary>
/// Execute an .NET Core Extensibility Tool.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="projectPath">The project path.</param>
/// <param name="command">The command to execute.</param>
/// <param name="arguments">The arguments.</param>
/// <example>
/// <code>
/// DotNetCoreTool("./src/project", "xunit", "-xml report.xml");
/// </code>
/// </example>
public void DotNetCoreTool(Cake.Core.IO.FilePath projectPath, System.String command, Cake.Core.IO.ProcessArgumentBuilder arguments)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreTool(Context, projectPath, command, arguments);
}
/// <summary>
/// Execute an .NET Core Extensibility Tool.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="projectPath">The project path.</param>
/// <param name="command">The command to execute.</param>
/// <param name="arguments">The arguments.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// DotNetCoreTool("./src/project", "xunit", "-xml report.xml");
/// </code>
/// </example>
public void DotNetCoreTool(Cake.Core.IO.FilePath projectPath, System.String command, Cake.Core.IO.ProcessArgumentBuilder arguments, Cake.Common.Tools.DotNetCore.Tool.DotNetCoreToolSettings settings)
{
Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreTool(Context, projectPath, command, arguments, settings);
}
/// <summary>
/// Runs <see href="https://www.jetbrains.com/dotcover/help/dotCover__Console_Runner_Commands.html#analyse">DotCover Analyse</see>
/// for the specified action and settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="action">The action to run DotCover for.</param>
/// <param name="outputFile">The DotCover output file.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// DotCoverAnalyse(tool =&gt; {
/// tool.XUnit2("./**/App.Tests.dll",
/// new XUnit2Settings {
/// ShadowCopy = false
/// });
/// },
/// new FilePath("./result.xml"),
/// new DotCoverAnalyseSettings()
/// .WithFilter("+:App")
/// .WithFilter("-:App.Tests"));
/// </code>
/// </example>
public void DotCoverAnalyse(System.Action<Cake.Core.ICakeContext> action, Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.DotCover.Analyse.DotCoverAnalyseSettings settings)
{
Cake.Common.Tools.DotCover.DotCoverAliases.DotCoverAnalyse(Context, action, outputFile, settings);
}
/// <summary>
/// Runs <see href="https://www.jetbrains.com/dotcover/help/dotCover__Console_Runner_Commands.html#cover">DotCover Cover</see>
/// for the specified action and settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="action">The action to run DotCover for.</param>
/// <param name="outputFile">The DotCover output file.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// DotCoverCover(tool =&gt; {
/// tool.XUnit2("./**/App.Tests.dll",
/// new XUnit2Settings {
/// ShadowCopy = false
/// });
/// },
/// new FilePath("./result.dcvr"),
/// new DotCoverCoverSettings()
/// .WithFilter("+:App")
/// .WithFilter("-:App.Tests"));
/// </code>
/// </example>
public void DotCoverCover(System.Action<Cake.Core.ICakeContext> action, Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.DotCover.Cover.DotCoverCoverSettings settings)
{
Cake.Common.Tools.DotCover.DotCoverAliases.DotCoverCover(Context, action, outputFile, settings);
}
/// <summary>
/// Runs <see href="https://www.jetbrains.com/dotcover/help/dotCover__Console_Runner_Commands.html#report">DotCover Report</see>
/// for the specified action and settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="sourceFile">The DotCover coverage snapshot file name.</param>
/// <param name="outputFile">The DotCover output file.</param>
/// <param name="settings">The settings</param>
/// <example>
/// <code>
/// DotCoverReport(new FilePath("./result.dcvr"),
/// new FilePath("./result.html"),
/// new DotCoverReportSettings {
/// ReportType = DotCoverReportType.HTML
/// });
/// </code>
/// </example>
public void DotCoverReport(Cake.Core.IO.FilePath sourceFile, Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.DotCover.Report.DotCoverReportSettings settings)
{
Cake.Common.Tools.DotCover.DotCoverAliases.DotCoverReport(Context, sourceFile, outputFile, settings);
}
/// <summary>
/// Runs <see href="https://www.jetbrains.com/dotcover/help/dotCover__Console_Runner_Commands.html#merge">DotCover Merge</see>
/// for the specified action and settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="sourceFiles">The list of DotCover coverage snapshot files.</param>
/// <param name="outputFile">The merged output file.</param>
/// <example>
/// <code>
/// DotCoverMerge(new[] {
/// new FilePath("./result1.dcvr"),
/// new FilePath("./result2.dcvr")
/// },
/// new FilePath("./merged.dcvr"));
/// </code>
/// </example>
public void DotCoverMerge(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> sourceFiles, Cake.Core.IO.FilePath outputFile)
{
Cake.Common.Tools.DotCover.DotCoverAliases.DotCoverMerge(Context, sourceFiles, outputFile);
}
/// <summary>
/// Runs <see href="https://www.jetbrains.com/dotcover/help/dotCover__Console_Runner_Commands.html#merge">DotCover Merge</see>
/// for the specified action and settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="sourceFiles">The list of DotCover coverage snapshot files.</param>
/// <param name="outputFile">The merged output file.</param>
/// <param name="settings">The settings</param>
/// <example>
/// <code>
/// DotCoverMerge(new[] {
/// new FilePath("./result1.dcvr"),
/// new FilePath("./result2.dcvr")
/// },
/// new FilePath("./merged.dcvr"),
/// new DotCoverMergeSettings {
/// LogFile = new FilePath("./log.txt")
/// });
/// </code>
/// </example>
public void DotCoverMerge(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> sourceFiles, Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.DotCover.Merge.DotCoverMergeSettings settings)
{
Cake.Common.Tools.DotCover.DotCoverAliases.DotCoverMerge(Context, sourceFiles, outputFile, settings);
}
/// <summary>
/// Creates a Chocolatey package using the specified Nuspec file.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="nuspecFilePath">The nuspec file path.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var chocolateyPackSettings = new ChocolateyPackSettings {
/// Id = "TestChocolatey",
/// Title = "The tile of the package",
/// Version = "0.0.0.1",
/// Authors = new[] {"John Doe"},
/// Owners = new[] {"Contoso"},
/// Summary = "Excellent summary of what the package does",
/// Description = "The description of the package",
/// ProjectUrl = new Uri("https://github.com/SomeUser/TestChocolatey/"),
/// PackageSourceUrl = new Uri("https://github.com/SomeUser/TestChocolatey/"),
/// ProjectSourceUrl = new Uri("https://github.com/SomeUser/TestChocolatey/"),
/// DocsUrl = new Uri("https://github.com/SomeUser/TestChocolatey/"),
/// MailingListUrl = new Uri("https://github.com/SomeUser/TestChocolatey/"),
/// BugTrackerUrl = new Uri("https://github.com/SomeUser/TestChocolatey/"),
/// Tags = new [] {"Cake", "Script", "Build"},
/// Copyright = "Some company 2015",
/// LicenseUrl = new Uri("https://github.com/SomeUser/TestChocolatey/blob/master/LICENSE.md"),
/// RequireLicenseAcceptance= false,
/// IconUrl = new Uri("http://cdn.rawgit.com/SomeUser/TestChocolatey/master/icons/testchocolatey.png"),
/// ReleaseNotes = new [] {"Bug fixes", "Issue fixes", "Typos"},
/// Files = new [] {
/// new ChocolateyNuSpecContent {Source = "bin/TestChocolatey.dll", Target = "bin"},
/// },
/// Debug = false,
/// Verbose = false,
/// Force = false,
/// Noop = false,
/// LimitOutput = false,
/// ExecutionTimeout = 13,
/// CacheLocation = @"C:\temp",
/// AllowUnofficial = false
/// };
///
/// ChocolateyPack("./nuspec/TestChocolatey.nuspec", chocolateyPackSettings);
/// </code>
/// </example>
public void ChocolateyPack(Cake.Core.IO.FilePath nuspecFilePath, Cake.Common.Tools.Chocolatey.Pack.ChocolateyPackSettings settings)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyPack(Context, nuspecFilePath, settings);
}
/// <summary>
/// Creates Chocolatey packages using the specified Nuspec files.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="filePaths">The nuspec file paths.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var chocolateyPackSettings = new ChocolateyPackSettings {
/// Id = "TestChocolatey",
/// Title = "The tile of the package",
/// Version = "0.0.0.1",
/// Authors = new[] {"John Doe"},
/// Owners = new[] {"Contoso"},
/// Summary = "Excellent summary of what the package does",
/// Description = "The description of the package",
/// ProjectUrl = new Uri("https://github.com/SomeUser/TestChocolatey/"),
/// PackageSourceUrl = new Uri("https://github.com/SomeUser/TestChocolatey/"),
/// ProjectSourceUrl = new Uri("https://github.com/SomeUser/TestChocolatey/"),
/// DocsUrl = new Uri("https://github.com/SomeUser/TestChocolatey/"),
/// MailingListUrl = new Uri("https://github.com/SomeUser/TestChocolatey/"),
/// BugTrackerUrl = new Uri("https://github.com/SomeUser/TestChocolatey/"),
/// Tags = new [] {"Cake", "Script", "Build"},
/// Copyright = "Some company 2015",
/// LicenseUrl = new Uri("https://github.com/SomeUser/TestChocolatey/blob/master/LICENSE.md"),
/// RequireLicenseAcceptance= false,
/// IconUrl = new Uri("http://cdn.rawgit.com/SomeUser/TestChocolatey/master/icons/testchocolatey.png"),
/// ReleaseNotes = new [] {"Bug fixes", "Issue fixes", "Typos"},
/// Files = new [] {
/// new ChocolateyNuSpecContent {Source = "bin/TestChocolatey.dll", Target = "bin"},
/// },
/// Debug = false,
/// Verbose = false,
/// Force = false,
/// Noop = false,
/// LimitOutput = false,
/// ExecutionTimeout = 13,
/// CacheLocation = @"C:\temp",
/// AllowUnofficial = false
/// };
///
/// var nuspecFiles = GetFiles("./**/*.nuspec");
/// ChocolateyPack(nuspecFiles, chocolateyPackSettings);
/// </code>
/// </example>
public void ChocolateyPack(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> filePaths, Cake.Common.Tools.Chocolatey.Pack.ChocolateyPackSettings settings)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyPack(Context, filePaths, settings);
}
/// <summary>
/// Creates a Chocolatey package using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var chocolateyPackSettings = new ChocolateyPackSettings {
/// Id = "TestChocolatey",
/// Title = "The tile of the package",
/// Version = "0.0.0.1",
/// Authors = new[] {"John Doe"},
/// Owners = new[] {"Contoso"},
/// Summary = "Excellent summary of what the package does",
/// Description = "The description of the package",
/// ProjectUrl = new Uri("https://github.com/SomeUser/TestChocolatey/"),
/// PackageSourceUrl = new Uri("https://github.com/SomeUser/TestChocolatey/"),
/// ProjectSourceUrl = new Uri("https://github.com/SomeUser/TestChocolatey/"),
/// DocsUrl = new Uri("https://github.com/SomeUser/TestChocolatey/"),
/// MailingListUrl = new Uri("https://github.com/SomeUser/TestChocolatey/"),
/// BugTrackerUrl = new Uri("https://github.com/SomeUser/TestChocolatey/"),
/// Tags = new [] {"Cake", "Script", "Build"},
/// Copyright = "Some company 2015",
/// LicenseUrl = new Uri("https://github.com/SomeUser/TestChocolatey/blob/master/LICENSE.md"),
/// RequireLicenseAcceptance= false,
/// IconUrl = new Uri("http://cdn.rawgit.com/SomeUser/TestChocolatey/master/icons/testchocolatey.png"),
/// ReleaseNotes = new [] {"Bug fixes", "Issue fixes", "Typos"},
/// Files = new [] {
/// new ChocolateyNuSpecContent {Source = "bin/TestChocolatey.dll", Target = "bin"},
/// },
/// Debug = false,
/// Verbose = false,
/// Force = false,
/// Noop = false,
/// LimitOutput = false,
/// ExecutionTimeout = 13,
/// CacheLocation = @"C:\temp",
/// AllowUnofficial = false
/// };
///
/// ChocolateyPack(chocolateyPackSettings);
/// </code>
/// </example>
public void ChocolateyPack(Cake.Common.Tools.Chocolatey.Pack.ChocolateyPackSettings settings)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyPack(Context, settings);
}
/// <summary>
/// Installs a Chocolatey package.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to install.</param>
/// <example>
/// <code>
/// ChocolateyInstall("MyChocolateyPackage");
/// </code>
/// </example>
public void ChocolateyInstall(System.String packageId)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyInstall(Context, packageId);
}
/// <summary>
/// Installs a Chocolatey package using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to install.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// ChocolateyInstall("MyChocolateyPackage", new ChocolateyInstallSettings {
/// Source = true,
/// Version = "1.2.3",
/// Prerelease = false,
/// Forcex86 = false,
/// InstallArguments = "arg1",
/// OverrideArguments = false,
/// NotSilent = false,
/// PackageParameters = "param1",
/// AllowDowngrade = false,
/// SideBySide = false,
/// IgnoreDependencies = false,
/// ForceDependencies = false,
/// SkipPowerShell = false,
/// User = "user",
/// Password = "password",
/// IgnoreChecksums = false,
/// Debug = false,
/// Verbose = false,
/// Force = false,
/// Noop = false,
/// LimitOutput = false,
/// ExecutionTimeout = 13,
/// CacheLocation = @"C:\temp",
/// AllowUnofficial = false
/// });
/// </code>
/// </example>
public void ChocolateyInstall(System.String packageId, Cake.Common.Tools.Chocolatey.Install.ChocolateyInstallSettings settings)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyInstall(Context, packageId, settings);
}
/// <summary>
/// Installs Chocolatey packages using the specified package configuration.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageConfigPath">The package configuration to install.</param>
/// <example>
/// <code>
/// ChocolateyInstallFromConfig("./tools/packages.config");
/// </code>
/// </example>
public void ChocolateyInstallFromConfig(Cake.Core.IO.FilePath packageConfigPath)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyInstallFromConfig(Context, packageConfigPath);
}
/// <summary>
/// Installs Chocolatey packages using the specified package configuration and settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageConfigPath">The package configuration to install.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// ChocolateyInstallFromConfig("./tools/packages.config", new ChocolateyInstallSettings {
/// Source = true,
/// Version = "1.2.3",
/// Prerelease = false,
/// Forcex86 = false,
/// InstallArguments = "arg1",
/// OverrideArguments = false,
/// NotSilent = false,
/// PackageParameters = "param1",
/// AllowDowngrade = false,
/// SideBySide = false,
/// IgnoreDependencies = false,
/// ForceDependencies = false,
/// SkipPowerShell = false,
/// User = "user",
/// Password = "password",
/// IgnoreChecksums = false,
/// Debug = false,
/// Verbose = false,
/// Force = false,
/// Noop = false,
/// LimitOutput = false,
/// ExecutionTimeout = 13,
/// CacheLocation = @"C:\temp",
/// AllowUnofficial = false
/// });
/// </code>
/// </example>
public void ChocolateyInstallFromConfig(Cake.Core.IO.FilePath packageConfigPath, Cake.Common.Tools.Chocolatey.Install.ChocolateyInstallSettings settings)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyInstallFromConfig(Context, packageConfigPath, settings);
}
/// <summary>
/// Uninstalls a Chocolatey package.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to uninstall.</param>
/// <example>
/// <code>
/// ChocolateyUninstall("MyChocolateyPackage");
/// </code>
/// </example>
public void ChocolateyUninstall(System.String packageId)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyUninstall(Context, packageId);
}
/// <summary>
/// Uninstalls a Chocolatey package using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to uninstall.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// ChocolateyUninstall("MyChocolateyPackage", new ChocolateyUninstallSettings {
/// Source = true,
/// Version = "1.2.3",
/// UninstallArguments = "arg1",
/// OverrideArguments = false,
/// NotSilent = false,
/// PackageParameters = "param1",
/// SideBySide = false,
/// IgnoreDependencies = false,
/// ForceDependencies = false,
/// SkipPowerShell = false,
/// Debug = false,
/// Verbose = false,
/// FailOnStandardError = false,
/// UseSystemPowershell = false,
/// AllVersions = false,
/// Force = false,
/// Noop = false,
/// LimitOutput = false,
/// ExecutionTimeout = 13,
/// CacheLocation = @"C:\temp",
/// AllowUnofficial = false,
/// GlobalArguments = false,
/// GlobalPackageParameters = false,
/// IgnorePackageExitCodes = false,
/// UsePackageExitCodes = false,
/// UseAutoUninstaller = false,
/// SkipAutoUninstaller = false,
/// FailOnAutoUninstaller = false,
/// IgnoreAutoUninstaller = false
/// });
/// </code>
/// </example>
public void ChocolateyUninstall(System.String packageId, Cake.Common.Tools.Chocolatey.Uninstall.ChocolateyUninstallSettings settings)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyUninstall(Context, packageId, settings);
}
/// <summary>
/// Uninstalls a Chocolatey package.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageIds">The ids of the packages to uninstall.</param>
/// <example>
/// <code>
/// ChocolateyUninstall("MyChocolateyPackage");
/// </code>
/// </example>
public void ChocolateyUninstall(System.Collections.Generic.IEnumerable<System.String> packageIds)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyUninstall(Context, packageIds);
}
/// <summary>
/// Uninstalls Chocolatey packages using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageIds">The ids of the packages to uninstall.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// ChocolateyUninstall("MyChocolateyPackage", new ChocolateyUninstallSettings {
/// Source = true,
/// Version = "1.2.3",
/// UninstallArguments = "arg1",
/// OverrideArguments = false,
/// NotSilent = false,
/// PackageParameters = "param1",
/// SideBySide = false,
/// IgnoreDependencies = false,
/// ForceDependencies = false,
/// SkipPowerShell = false,
/// Debug = false,
/// Verbose = false,
/// FailOnStandardError = false,
/// UseSystemPowershell = false,
/// AllVersions = false,
/// Force = false,
/// Noop = false,
/// LimitOutput = false,
/// ExecutionTimeout = 13,
/// CacheLocation = @"C:\temp",
/// AllowUnofficial = false,
/// GlobalArguments = false,
/// GlobalPackageParameters = false,
/// IgnorePackageExitCodes = false,
/// UsePackageExitCodes = false,
/// UseAutoUninstaller = false,
/// SkipAutoUninstaller = false,
/// FailOnAutoUninstaller = false,
/// IgnoreAutoUninstaller = false
/// });
/// </code>
/// </example>
public void ChocolateyUninstall(System.Collections.Generic.IEnumerable<System.String> packageIds, Cake.Common.Tools.Chocolatey.Uninstall.ChocolateyUninstallSettings settings)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyUninstall(Context, packageIds, settings);
}
/// <summary>
/// Pins a Chocolatey package using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="name">The name.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// ChocolateyPin("MyChocolateyPackage", new ChocolateyPinSettings {
/// Version = "1.2.3",
/// Debug = false,
/// Verbose = false,
/// Force = false,
/// Noop = false,
/// LimitOutput = false,
/// ExecutionTimeout = 13,
/// CacheLocation = @"C:\temp",
/// AllowUnofficial = false
/// });
/// </code>
/// </example>
public void ChocolateyPin(System.String name, Cake.Common.Tools.Chocolatey.Pin.ChocolateyPinSettings settings)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyPin(Context, name, settings);
}
/// <summary>
/// Sets the Api Key for a Chocolatey Source using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="apiKey">The API Key.</param>
/// <param name="source">The source.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// ChocolateyApiKey("myApiKey", "http://www.mysource.com", new ChocolateyApiKeySettings {
/// Debug = false,
/// Verbose = false,
/// Force = false,
/// Noop = false,
/// LimitOutput = false,
/// ExecutionTimeout = 13,
/// CacheLocation = @"C:\temp",
/// AllowUnofficial = false
/// });
/// </code>
/// </example>
public void ChocolateyApiKey(System.String apiKey, System.String source, Cake.Common.Tools.Chocolatey.ApiKey.ChocolateyApiKeySettings settings)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyApiKey(Context, apiKey, source, settings);
}
/// <summary>
/// Sets the config parameter using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="name">The name.</param>
/// <param name="value">The value.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// ChocolateyConfig("cacheLocation", @"c:\temp", new ChocolateyConfigSettings {
/// Debug = false,
/// Verbose = false,
/// Force = false,
/// Noop = false,
/// LimitOutput = false,
/// ExecutionTimeout = 13,
/// CacheLocation = @"C:\temp",
/// AllowUnofficial = false
/// });
/// </code>
/// </example>
public void ChocolateyConfig(System.String name, System.String value, Cake.Common.Tools.Chocolatey.Config.ChocolateyConfigSettings settings)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyConfig(Context, name, value, settings);
}
/// <summary>
/// Enables a Chocolatey Feature using the specified name
/// </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the feature.</param>
/// <example>
/// <code>
/// ChocolateyEnableFeature("checkSumFiles");
/// </code>
/// </example>
public void ChocolateyEnableFeature(System.String name)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyEnableFeature(Context, name);
}
/// <summary>
/// Enables a Chocolatey Feature using the specified name and settings
/// </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the feature.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// ChocolateyEnableFeature("checkSumFiles", new ChocolateyFeatureSettings {
/// Debug = false,
/// Verbose = false,
/// Force = false,
/// Noop = false,
/// LimitOutput = false,
/// ExecutionTimeout = 13,
/// CacheLocation = @"C:\temp",
/// AllowUnofficial = false
/// });
/// </code>
/// </example>
public void ChocolateyEnableFeature(System.String name, Cake.Common.Tools.Chocolatey.Features.ChocolateyFeatureSettings settings)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyEnableFeature(Context, name, settings);
}
/// <summary>
/// Disables a Chocolatey Feature using the specified name
/// </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the feature.</param>
/// <example>
/// <code>
/// ChocolateyDisableFeature("checkSumFiles");
/// </code>
/// </example>
public void ChocolateyDisableFeature(System.String name)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyDisableFeature(Context, name);
}
/// <summary>
/// Disables a Chocolatey Feature using the specified name and settings
/// </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the feature.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// ChocolateyDisableFeature("checkSumFiles", new ChocolateyFeatureSettings {
/// Debug = false,
/// Verbose = false,
/// Force = false,
/// Noop = false,
/// LimitOutput = false,
/// ExecutionTimeout = 13,
/// CacheLocation = @"C:\temp",
/// AllowUnofficial = false
/// });
/// </code>
/// </example>
public void ChocolateyDisableFeature(System.String name, Cake.Common.Tools.Chocolatey.Features.ChocolateyFeatureSettings settings)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyDisableFeature(Context, name, settings);
}
/// <summary>
/// Adds Chocolatey package source using the specified name &amp;source to global user config
/// </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the source.</param>
/// <param name="source">Path to the package(s) source.</param>
/// <example>
/// <code>
/// ChocolateyAddSource("MySource", "http://www.mysource.com");
/// </code>
/// </example>
public void ChocolateyAddSource(System.String name, System.String source)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyAddSource(Context, name, source);
}
/// <summary>
/// Adds Chocolatey package source using the specified name, source &amp; settings to global user config
/// </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the source.</param>
/// <param name="source">Path to the package(s) source.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// ChocolateyAddSource("MySource", "http://www.mysource.com", new ChocolateySourcesSettings {
/// UserName = "user",
/// Password = "password",
/// Priority = 13,
/// Debug = false,
/// Verbose = false,
/// Force = false,
/// Noop = false,
/// LimitOutput = false,
/// ExecutionTimeout = 13,
/// CacheLocation = @"C:\temp",
/// AllowUnofficial = false
/// });
/// </code>
/// </example>
public void ChocolateyAddSource(System.String name, System.String source, Cake.Common.Tools.Chocolatey.Sources.ChocolateySourcesSettings settings)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyAddSource(Context, name, source, settings);
}
/// <summary>
/// Removes Chocolatey package source using the specified name &amp; source from global user config
/// </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the source.</param>
/// <example>
/// <code>
/// ChocolateyRemoveSource("MySource");
/// </code>
/// </example>
public void ChocolateyRemoveSource(System.String name)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyRemoveSource(Context, name);
}
/// <summary>
/// Removes Chocolatey package source using the specified name, source &amp; settings from global user config
/// </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the source.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// ChocolateyRemoveSource("MySource", new ChocolateySourcesSettings {
/// Debug = false,
/// Verbose = false,
/// Force = false,
/// Noop = false,
/// LimitOutput = false,
/// ExecutionTimeout = 13,
/// CacheLocation = @"C:\temp",
/// AllowUnofficial = false
/// });
/// </code>
/// </example>
public void ChocolateyRemoveSource(System.String name, Cake.Common.Tools.Chocolatey.Sources.ChocolateySourcesSettings settings)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyRemoveSource(Context, name, settings);
}
/// <summary>
/// Enables a Chocolatey Source using the specified name
/// </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the source.</param>
/// <example>
/// <code>
/// ChocolateyEnableSource("MySource");
/// </code>
/// </example>
public void ChocolateyEnableSource(System.String name)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyEnableSource(Context, name);
}
/// <summary>
/// Enables a Chocolatey Source using the specified name and settings
/// </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the source.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// ChocolateyEnableSource("MySource", new ChocolateySourcesSettings {
/// Debug = false,
/// Verbose = false,
/// Force = false,
/// Noop = false,
/// LimitOutput = false,
/// ExecutionTimeout = 13,
/// CacheLocation = @"C:\temp",
/// AllowUnofficial = false
/// });
/// </code>
/// </example>
public void ChocolateyEnableSource(System.String name, Cake.Common.Tools.Chocolatey.Sources.ChocolateySourcesSettings settings)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyEnableSource(Context, name, settings);
}
/// <summary>
/// Disables a Chocolatey Source using the specified name
/// </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the source.</param>
/// <example>
/// <code>
/// ChocolateyDisableSource("MySource");
/// </code>
/// </example>
public void ChocolateyDisableSource(System.String name)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyDisableSource(Context, name);
}
/// <summary>
/// Disables a Chocolatey Source using the specified name and settings
/// </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the source.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// ChocolateyDisableSource("MySource", new ChocolateySourcesSettings {
/// Debug = false,
/// Verbose = false,
/// Force = false,
/// Noop = false,
/// LimitOutput = false,
/// ExecutionTimeout = 13,
/// CacheLocation = @"C:\temp",
/// AllowUnofficial = false
/// });
/// </code>
/// </example>
public void ChocolateyDisableSource(System.String name, Cake.Common.Tools.Chocolatey.Sources.ChocolateySourcesSettings settings)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyDisableSource(Context, name, settings);
}
/// <summary>
/// Pushes a Chocolatey package to a Chocolatey server and publishes it.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageFilePath">The <c>.nupkg</c> file path.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// // Get the path to the package.
/// var package = "./chocolatey/MyChocolateyPackage.0.0.1.nupkg";
///
/// // Push the package.
/// ChocolateyPush(package, new ChocolateyPushSettings {
/// Source = "http://example.com/chocolateyfeed",
/// ApiKey = "4003d786-cc37-4004-bfdf-c4f3e8ef9b3a"
/// Timeout = 300
/// Debug = false,
/// Verbose = false,
/// Force = false,
/// Noop = false,
/// LimitOutput = false,
/// ExecutionTimeout = 13,
/// CacheLocation = @"C:\temp",
/// AllowUnofficial = false
/// });
/// </code>
/// </example>
public void ChocolateyPush(Cake.Core.IO.FilePath packageFilePath, Cake.Common.Tools.Chocolatey.Push.ChocolateyPushSettings settings)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyPush(Context, packageFilePath, settings);
}
/// <summary>
/// Pushes Chocolatey packages to a Chocolatey server and publishes them.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageFilePaths">The <c>.nupkg</c> file paths.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// // Get the paths to the packages.
/// var packages = GetFiles("./**/*.nupkg");
///
/// // Push the package.
/// ChocolateyPush(packages, new ChocolateyPushSettings {
/// Source = "http://example.com/chocolateyfeed",
/// ApiKey = "4003d786-cc37-4004-bfdf-c4f3e8ef9b3a"
/// Timeout = 300
/// Debug = false,
/// Verbose = false,
/// Force = false,
/// Noop = false,
/// LimitOutput = false,
/// ExecutionTimeout = 13,
/// CacheLocation = @"C:\temp",
/// AllowUnofficial = false
/// });
/// </code>
/// </example>
public void ChocolateyPush(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> packageFilePaths, Cake.Common.Tools.Chocolatey.Push.ChocolateyPushSettings settings)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyPush(Context, packageFilePaths, settings);
}
/// <summary>
/// Upgrades Chocolatey package.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to upgrade.</param>
/// <example>
/// <code>
/// ChocolateyUpgrade("MyChocolateyPackage");
/// </code>
/// </example>
public void ChocolateyUpgrade(System.String packageId)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyUpgrade(Context, packageId);
}
/// <summary>
/// Upgrades Chocolatey package using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to upgrade.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// ChocolateyUpgrade("MyChocolateyPackage", new ChocolateyUpgradeSettings {
/// Source = true,
/// Version = "1.2.3",
/// Prerelease = false,
/// Forcex86 = false,
/// InstallArguments = "arg1",
/// OverrideArguments = false,
/// NotSilent = false,
/// PackageParameters = "param1",
/// AllowDowngrade = false,
/// SideBySide = false,
/// IgnoreDependencies = false,
/// SkipPowerShell = false,
/// FailOnUnfound = false,
/// FailOnNotInstalled = false,
/// User = "user",
/// Password = "password",
/// IgnoreChecksums = false,
/// Debug = false,
/// Verbose = false,
/// Force = false,
/// Noop = false,
/// LimitOutput = false,
/// ExecutionTimeout = 13,
/// CacheLocation = @"C:\temp",
/// AllowUnofficial = false
/// });
/// </code>
/// </example>
public void ChocolateyUpgrade(System.String packageId, Cake.Common.Tools.Chocolatey.Upgrade.ChocolateyUpgradeSettings settings)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyUpgrade(Context, packageId, settings);
}
/// <summary>
/// Generate package specification files for a new package using the default settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to create.</param>
/// <example>
/// <code>
/// ChocolateyNew("MyChocolateyPackage");
/// </code>
/// </example>
public void ChocolateyNew(System.String packageId)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyNew(Context, packageId);
}
/// <summary>
/// Generate package specification files for a new package using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to create.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// ChocolateyNew("MyChocolateyPackage", new ChocolateyNewSettings {
/// PackageVersion = "1.2.3",
/// MaintainerName = "John Doe",
/// MaintainerRepo = "johndoe"
/// });
/// </code>
/// </example>
/// <example>
/// <code>
/// var settings = new ChocolateyNewSettings {
/// MaintainerName = "John Doe"
/// }
/// settings.AdditionalPropertyValues("Tags", "CustomPackage");
/// ChocolateyNew("MyChocolateyPackage", settings);
/// </code>
/// </example>
public void ChocolateyNew(System.String packageId, Cake.Common.Tools.Chocolatey.New.ChocolateyNewSettings settings)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyNew(Context, packageId, settings);
}
/// <summary>
/// Downloads a Chocolatey package to the current working directory.
/// Requires Chocolatey licensed edition.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to download.</param>
/// <example>
/// <code>
/// ChocolateyDownload("MyChocolateyPackage");
/// </code>
/// </example>
public void ChocolateyDownload(System.String packageId)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyDownload(Context, packageId);
}
/// <summary>
/// Downloads a Chocolatey package using the specified settings.
/// Requires Chocolatey licensed edition.
/// Features requiring Chocolatey for Business or a minimum version are documented
/// in <see cref="T:Cake.Common.Tools.Chocolatey.Download.ChocolateyDownloadSettings" />.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to install.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <para>Download a package to a specific folder:</para>
/// <code>
/// ChocolateyDownload(
/// "MyChocolateyPackage",
/// new ChocolateyDownloadSettings {
/// OutputDirectory = @"C:\download\"
/// });
/// </code>
/// <para>Download and internalize a package:</para>
/// <code>
/// ChocolateyDownload(
/// "MyChocolateyPackage",
/// new ChocolateyDownloadSettings {
/// Internalize = true
/// });
/// </code>
/// </example>
public void ChocolateyDownload(System.String packageId, Cake.Common.Tools.Chocolatey.Download.ChocolateyDownloadSettings settings)
{
Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyDownload(Context, packageId, settings);
}
/// <summary>
/// Runs all xUnit.net v2 tests in the assemblies matching the specified pattern.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <example>
/// <code>
/// XUnit2("./src/**/bin/Release/*.Tests.dll");
/// </code>
/// </example>
public void XUnit2(System.String pattern)
{
Cake.Common.Tools.XUnit.XUnit2Aliases.XUnit2(Context, pattern);
}
/// <summary>
/// Runs all xUnit.net v2 tests in the assemblies matching the specified pattern.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// XUnit2("./src/**/bin/Release/*.Tests.dll",
/// new XUnit2Settings {
/// Parallelism = ParallelismOption.All,
/// HtmlReport = true,
/// NoAppDomain = true,
/// OutputDirectory = "./build"
/// });
/// </code>
/// </example>
public void XUnit2(System.String pattern, Cake.Common.Tools.XUnit.XUnit2Settings settings)
{
Cake.Common.Tools.XUnit.XUnit2Aliases.XUnit2(Context, pattern, settings);
}
/// <summary>
/// Runs all xUnit.net v2 tests in the specified assemblies.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <example>
/// <code>
/// XUnit2(new []{
/// "./src/Cake.Common.Tests/bin/Release/Cake.Common.Tests.dll",
/// "./src/Cake.Core.Tests/bin/Release/Cake.Core.Tests.dll",
/// "./src/Cake.NuGet.Tests/bin/Release/Cake.NuGet.Tests.dll",
/// "./src/Cake.Tests/bin/Release/Cake.Tests.dll"
/// });
/// </code>
/// </example>
public void XUnit2(System.Collections.Generic.IEnumerable<System.String> assemblies)
{
Cake.Common.Tools.XUnit.XUnit2Aliases.XUnit2(Context, assemblies);
}
/// <summary>
/// Runs all xUnit.net tests in the specified assemblies.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <example>
/// <code>
/// var testAssemblies = GetFiles("./src/**/bin/Release/*.Tests.dll");
/// XUnit2(testAssemblies);
/// </code>
/// </example>
public void XUnit2(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblies)
{
Cake.Common.Tools.XUnit.XUnit2Aliases.XUnit2(Context, assemblies);
}
/// <summary>
/// Runs all xUnit.net v2 tests in the specified assemblies.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// XUnit2(new []{
/// "./src/Cake.Common.Tests/bin/Release/Cake.Common.Tests.dll",
/// "./src/Cake.Core.Tests/bin/Release/Cake.Core.Tests.dll",
/// "./src/Cake.NuGet.Tests/bin/Release/Cake.NuGet.Tests.dll",
/// "./src/Cake.Tests/bin/Release/Cake.Tests.dll"
/// },
/// new XUnit2Settings {
/// Parallelism = ParallelismOption.All,
/// HtmlReport = true,
/// NoAppDomain = true,
/// OutputDirectory = "./build"
/// });
/// </code>
/// </example>
public void XUnit2(System.Collections.Generic.IEnumerable<System.String> assemblies, Cake.Common.Tools.XUnit.XUnit2Settings settings)
{
Cake.Common.Tools.XUnit.XUnit2Aliases.XUnit2(Context, assemblies, settings);
}
/// <summary>
/// Runs all xUnit.net v2 tests in the specified assemblies.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var testAssemblies = GetFiles("./src/**/bin/Release/*.Tests.dll");
/// XUnit2(testAssemblies,
/// new XUnit2Settings {
/// Parallelism = ParallelismOption.All,
/// HtmlReport = true,
/// NoAppDomain = true,
/// OutputDirectory = "./build"
/// });
/// </code>
/// </example>
public void XUnit2(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblies, Cake.Common.Tools.XUnit.XUnit2Settings settings)
{
Cake.Common.Tools.XUnit.XUnit2Aliases.XUnit2(Context, assemblies, settings);
}
/// <summary>
/// Runs all xUnit.net tests in the assemblies matching the specified pattern.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <example>
/// <code>
/// XUnit("./src/**/bin/Release/*.Tests.dll");
/// </code>
/// </example>
public void XUnit(System.String pattern)
{
Cake.Common.Tools.XUnit.XUnitAliases.XUnit(Context, pattern);
}
/// <summary>
/// Runs all xUnit.net tests in the assemblies matching the specified pattern.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// XUnit("./src/**/bin/Release/*.Tests.dll",
/// new XUnitSettings {
/// HtmlReport = true,
/// OutputDirectory = "./build"
/// });
/// </code>
/// </example>
public void XUnit(System.String pattern, Cake.Common.Tools.XUnit.XUnitSettings settings)
{
Cake.Common.Tools.XUnit.XUnitAliases.XUnit(Context, pattern, settings);
}
/// <summary>
/// Runs all xUnit.net tests in the specified assemblies.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <example>
/// <code>
/// XUnit(new []{
/// "./src/Cake.Common.Tests/bin/Release/Cake.Common.Tests.dll",
/// "./src/Cake.Core.Tests/bin/Release/Cake.Core.Tests.dll",
/// "./src/Cake.NuGet.Tests/bin/Release/Cake.NuGet.Tests.dll",
/// "./src/Cake.Tests/bin/Release/Cake.Tests.dll"
/// });
/// </code>
/// </example>
public void XUnit(System.Collections.Generic.IEnumerable<System.String> assemblies)
{
Cake.Common.Tools.XUnit.XUnitAliases.XUnit(Context, assemblies);
}
/// <summary>
/// Runs all xUnit.net tests in the specified assemblies.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <example>
/// <code>
/// var testAssemblies = GetFiles("./src/**/bin/Release/*.Tests.dll");
/// XUnit(testAssemblies);
/// </code>
/// </example>
public void XUnit(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblies)
{
Cake.Common.Tools.XUnit.XUnitAliases.XUnit(Context, assemblies);
}
/// <summary>
/// Runs all xUnit.net tests in the specified assemblies.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// XUnit(new []{
/// "./src/Cake.Common.Tests/bin/Release/Cake.Common.Tests.dll",
/// "./src/Cake.Core.Tests/bin/Release/Cake.Core.Tests.dll",
/// "./src/Cake.NuGet.Tests/bin/Release/Cake.NuGet.Tests.dll",
/// "./src/Cake.Tests/bin/Release/Cake.Tests.dll"
/// },
/// new XUnitSettings {
/// HtmlReport = true,
/// OutputDirectory = "./build"
/// });
/// </code>
/// </example>
public void XUnit(System.Collections.Generic.IEnumerable<System.String> assemblies, Cake.Common.Tools.XUnit.XUnitSettings settings)
{
Cake.Common.Tools.XUnit.XUnitAliases.XUnit(Context, assemblies, settings);
}
/// <summary>
/// Runs all xUnit.net tests in the specified assemblies.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var testAssemblies = GetFiles("./src/**/bin/Release/*.Tests.dll");
/// XUnit(testAssemblies,
/// new XUnitSettings {
/// HtmlReport = true,
/// OutputDirectory = "./build"
/// });
/// </code>
/// </example>
public void XUnit(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblies, Cake.Common.Tools.XUnit.XUnitSettings settings)
{
Cake.Common.Tools.XUnit.XUnitAliases.XUnit(Context, assemblies, settings);
}
/// <summary>
/// Builds the specified solution using XBuild.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="solution">The solution to build.</param>
/// <example>
/// <code>
/// XBuild("./src/Cake.sln");
/// </code>
/// </example>
public void XBuild(Cake.Core.IO.FilePath solution)
{
Cake.Common.Tools.XBuild.XBuildAliases.XBuild(Context, solution);
}
/// <summary>
/// Builds the specified solution using XBuild.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="solution">The solution to build.</param>
/// <param name="configurator">The settings configurator.</param>
/// <example>
/// <code>
/// XBuild("./src/Cake.sln", configurator =&gt;
/// configurator.SetConfiguration("Debug")
/// .SetVerbosity(Verbosity.Minimal)
/// .UseToolVersion(XBuildToolVersion.NET40));
/// </code>
/// </example>
public void XBuild(Cake.Core.IO.FilePath solution, System.Action<Cake.Common.Tools.XBuild.XBuildSettings> configurator)
{
Cake.Common.Tools.XBuild.XBuildAliases.XBuild(Context, solution, configurator);
}
/// <summary>
/// Builds the specified solution using XBuild.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="solution">The solution to build.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// XBuild("./src/Cake.sln", new XBuildSettings {
/// Verbosity = Verbosity.Minimal,
/// ToolVersion = XBuildToolVersion.NET40,
/// Configuration = "Release"
/// });
/// </code>
/// </example>
public void XBuild(Cake.Core.IO.FilePath solution, Cake.Common.Tools.XBuild.XBuildSettings settings)
{
Cake.Common.Tools.XBuild.XBuildAliases.XBuild(Context, solution, settings);
}
/// <summary>
/// Compiles all <c>.wxs</c> sources matching the specified pattern.
/// </summary>
/// <example>
/// <code>
/// CandleSettings settings = new CandleSettings {
/// Architecture = Architecture.X64,
/// Verbose = true
/// };
/// WiXCandle("./src/*.wxs", settings);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The globbing pattern.</param>
/// <param name="settings">The settings.</param>
public void WiXCandle(System.String pattern, Cake.Common.Tools.WiX.CandleSettings settings = null)
{
Cake.Common.Tools.WiX.WiXAliases.WiXCandle(Context, pattern, settings);
}
/// <summary>
/// Compiles all <c>.wxs</c> sources in the provided source files.
/// </summary>
/// <example>
/// <code>
/// var files = GetFiles("./src/*.wxs");
/// CandleSettings settings = new CandleSettings {
/// Architecture = Architecture.X64,
/// Verbose = true
/// };
/// WiXCandle(files, settings);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="sourceFiles">The source files.</param>
/// <param name="settings">The settings.</param>
public void WiXCandle(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> sourceFiles, Cake.Common.Tools.WiX.CandleSettings settings = null)
{
Cake.Common.Tools.WiX.WiXAliases.WiXCandle(Context, sourceFiles, settings);
}
/// <summary>
/// Links all <c>.wixobj</c> files matching the specified pattern.
/// </summary>
/// <example>
/// <code>
/// LightSettings settings = new LightSettings {
/// RawArguments = "-O1 -pedantic -v"
/// };
/// WiXLight("./src/*.wixobj", settings);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The globbing pattern.</param>
/// <param name="settings">The settings.</param>
public void WiXLight(System.String pattern, Cake.Common.Tools.WiX.LightSettings settings = null)
{
Cake.Common.Tools.WiX.WiXAliases.WiXLight(Context, pattern, settings);
}
/// <summary>
/// Links all <c>.wixobj</c> files in the provided object files.
/// </summary>
/// <example>
/// <code>
/// var files = GetFiles("./src/*.wxs");
/// LightSettings settings = new LightSettings {
/// RawArguments = "-O1 -pedantic -v"
/// };
/// WiXLight(files, settings);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="objectFiles">The object files.</param>
/// <param name="settings">The settings.</param>
public void WiXLight(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> objectFiles, Cake.Common.Tools.WiX.LightSettings settings = null)
{
Cake.Common.Tools.WiX.WiXAliases.WiXLight(Context, objectFiles, settings);
}
/// <summary>
/// Harvests files in the provided object files.
/// </summary>
/// <example>
/// <code>
/// DirectoryPath harvestDirectory = Directory("./src");
/// var filePath = new FilePath("Wix.Directory.wxs");
/// WiXHeat(harvestDirectory, filePath, WiXHarvestType.Dir);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="directoryPath">The object files.</param>
/// <param name="outputFile">The output file.</param>
/// <param name="harvestType">The WiX harvest type.</param>
public void WiXHeat(Cake.Core.IO.DirectoryPath directoryPath, Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.WiX.Heat.WiXHarvestType harvestType)
{
Cake.Common.Tools.WiX.WiXAliases.WiXHeat(Context, directoryPath, outputFile, harvestType);
}
/// <summary>
/// Harvests files in the provided directory path.
/// </summary>
/// <example>
/// <code>
/// DirectoryPath harvestDirectory = Directory("./src");
/// var filePath = File("Wix.Directory.wxs");
/// Information(MakeAbsolute(harvestDirectory).FullPath);
/// WiXHeat(harvestDirectory, filePath, WiXHarvestType.Dir, new HeatSettings { NoLogo = true });
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="directoryPath">The directory path.</param>
/// <param name="outputFile">The output file.</param>
/// <param name="harvestType">The WiX harvest type.</param>
/// <param name="settings">The settings.</param>
public void WiXHeat(Cake.Core.IO.DirectoryPath directoryPath, Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.WiX.Heat.WiXHarvestType harvestType, Cake.Common.Tools.WiX.Heat.HeatSettings settings)
{
Cake.Common.Tools.WiX.WiXAliases.WiXHeat(Context, directoryPath, outputFile, harvestType, settings);
}
/// <summary>
/// Harvests from the desired files.
/// </summary>
/// <example>
/// <code>
/// var harvestFile = File("./tools/Cake/Cake.Core.dll");
/// var filePath = File("Wix.File.wxs");
/// WiXHeat(harvestFile, filePath, WiXHarvestType.File);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="objectFile">The object file.</param>
/// <param name="outputFile">The output file.</param>
/// <param name="harvestType">The WiX harvest type.</param>
public void WiXHeat(Cake.Core.IO.FilePath objectFile, Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.WiX.Heat.WiXHarvestType harvestType)
{
Cake.Common.Tools.WiX.WiXAliases.WiXHeat(Context, objectFile, outputFile, harvestType);
}
/// <summary>
/// Harvests from the desired files.
/// </summary>
/// <example>
/// <code>
/// var harvestFiles = File("./tools/Cake/*.dll");
/// var filePath = File("Wix.File.wxs");
/// WiXHeat(harvestFiles, filePath, WiXHarvestType.File, new HeatSettings { NoLogo = true });
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="objectFile">The object file.</param>
/// <param name="outputFile">The output file.</param>
/// <param name="harvestType">The WiX harvest type.</param>
/// <param name="settings">The settings.</param>
public void WiXHeat(Cake.Core.IO.FilePath objectFile, Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.WiX.Heat.WiXHarvestType harvestType, Cake.Common.Tools.WiX.Heat.HeatSettings settings)
{
Cake.Common.Tools.WiX.WiXAliases.WiXHeat(Context, objectFile, outputFile, harvestType, settings);
}
/// <summary>
/// Harvests files for a website or performance.
/// </summary>
/// <example>
/// <code>
/// var filePath = File("Wix.Website.wxs");
/// WiXHeat("Default Web Site", filePath, WiXHarvestType.Website);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="harvestTarget">The harvest target.</param>
/// <param name="outputFile">The output file.</param>
/// <param name="harvestType">The WiX harvest type.</param>
public void WiXHeat(System.String harvestTarget, Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.WiX.Heat.WiXHarvestType harvestType)
{
Cake.Common.Tools.WiX.WiXAliases.WiXHeat(Context, harvestTarget, outputFile, harvestType);
}
/// <summary>
/// Harvests files for a website or performance.
/// </summary>
/// <example>
/// <code>
/// var filePath = File("Wix.Website.wxs");
/// WiXHeat("Default Web Site", filePath, WiXHarvestType.Website, new HeatSettings { NoLogo = true });
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="harvestTarget">The harvest target.</param>
/// <param name="outputFile">The output file.</param>
/// <param name="harvestType">The WiX harvest type.</param>
/// <param name="settings">The settings.</param>
public void WiXHeat(System.String harvestTarget, Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.WiX.Heat.WiXHarvestType harvestType, Cake.Common.Tools.WiX.Heat.HeatSettings settings)
{
Cake.Common.Tools.WiX.WiXAliases.WiXHeat(Context, harvestTarget, outputFile, harvestType, settings);
}
/// <summary>
/// Signs the specified assembly.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="assembly">The target assembly.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// Task("Sign")
/// .IsDependentOn("Clean")
/// .IsDependentOn("Restore")
/// .IsDependentOn("Build")
/// .Does(() =&gt;
/// {
/// var file = "Core.dll";
/// Sign(file, new SignToolSignSettings {
/// TimeStampUri = new Uri("http://timestamp.digicert.com"),
/// CertPath = "digitalcertificate.pfx",
/// Password = "TopSecret"
/// });
/// });
/// </code>
/// </example>
public void Sign(System.String assembly, Cake.Common.Tools.SignTool.SignToolSignSettings settings)
{
Cake.Common.Tools.SignTool.SignToolSignAliases.Sign(Context, assembly, settings);
}
/// <summary>
/// Signs the specified assembly.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="assembly">The target assembly.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// Task("Sign")
/// .IsDependentOn("Clean")
/// .IsDependentOn("Restore")
/// .IsDependentOn("Build")
/// .Does(() =&gt;
/// {
/// var file = new FilePath("Core.dll");
/// Sign(file, new SignToolSignSettings {
/// TimeStampUri = new Uri("http://timestamp.digicert.com"),
/// CertPath = "digitalcertificate.pfx",
/// Password = "TopSecret"
/// });
/// });
/// </code>
/// </example>
public void Sign(Cake.Core.IO.FilePath assembly, Cake.Common.Tools.SignTool.SignToolSignSettings settings)
{
Cake.Common.Tools.SignTool.SignToolSignAliases.Sign(Context, assembly, settings);
}
/// <summary>
/// Signs the specified assemblies.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The target assembly.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// Task("Sign")
/// .IsDependentOn("Clean")
/// .IsDependentOn("Restore")
/// .IsDependentOn("Build")
/// .Does(() =&gt;
/// {
/// var files = new string[] { "Core.dll", "Common.dll" };
/// Sign(files, new SignToolSignSettings {
/// TimeStampUri = new Uri("http://timestamp.digicert.com"),
/// CertPath = "digitalcertificate.pfx",
/// Password = "TopSecret"
/// });
/// });
/// </code>
/// </example>
public void Sign(System.Collections.Generic.IEnumerable<System.String> assemblies, Cake.Common.Tools.SignTool.SignToolSignSettings settings)
{
Cake.Common.Tools.SignTool.SignToolSignAliases.Sign(Context, assemblies, settings);
}
/// <summary>
/// Signs the specified assemblies.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The target assembly.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// Task("Sign")
/// .IsDependentOn("Clean")
/// .IsDependentOn("Restore")
/// .IsDependentOn("Build")
/// .Does(() =&gt;
/// {
/// var files = GetFiles(solutionDir + "/**/bin/" + configuration + "/**/*.exe");
/// Sign(files, new SignToolSignSettings {
/// TimeStampUri = new Uri("http://timestamp.digicert.com"),
/// CertPath = "digitalcertificate.pfx",
/// Password = "TopSecret"
/// });
/// });
/// </code>
/// </example>
public void Sign(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblies, Cake.Common.Tools.SignTool.SignToolSignSettings settings)
{
Cake.Common.Tools.SignTool.SignToolSignAliases.Sign(Context, assemblies, settings);
}
/// <summary>
/// Executes Roundhouse with the given configured settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// RoundhouseMigrate(new RoundhouseSettings{
/// ServerName = "Sql2008R2",
/// DatabaseName = "AdventureWorks2008R2",
/// SqlFilesDirectory = "./src/sql"
/// });
/// </code>
/// </example>
public void RoundhouseMigrate(Cake.Common.Tools.Roundhouse.RoundhouseSettings settings)
{
Cake.Common.Tools.Roundhouse.RoundhouseAliases.RoundhouseMigrate(Context, settings);
}
/// <summary>
/// Executes Roundhouse migration to drop the database using the provided settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// RoundhouseDrop(new RoundhouseSettings{
/// ServerName = "Sql2008R2",
/// DatabaseName = "AdventureWorks2008R2"
/// });
/// </code>
/// </example>
public void RoundhouseDrop(Cake.Common.Tools.Roundhouse.RoundhouseSettings settings)
{
Cake.Common.Tools.Roundhouse.RoundhouseAliases.RoundhouseDrop(Context, settings);
}
/// <summary>
/// Creates a release for the specified Octopus Deploy Project.
/// </summary>
/// <param name="context">The cake context.</param>
/// <param name="projectName">The name of the project.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// // Minimum required
/// OctoCreateRelease(projectNameOnServer, new CreateReleaseSettings {
/// Server = "http://octopus-deploy.example",
/// ApiKey = "API-XXXXXXXXXXXXXXXXXXXX"
/// });
///
/// OctoCreateRelease(projectNameOnServer, new CreateReleaseSettings {
/// Server = "http://octopus-deploy.example",
/// Username = "DeployUser",
/// Password = "a-very-secure-password"
/// });
///
/// OctoCreateRelease(projectNameOnServer, new CreateReleaseSettings {
/// ConfigurationFile = @"C:\OctopusDeploy.config"
/// });
///
/// // Additional Options
/// OctoCreateRelease(projectNameOnServer, new CreateReleaseSettings {
/// ToolPath = "./tools/OctopusTools/Octo.exe"
/// EnableDebugLogging = true,
/// IgnoreSslErrors = true,
/// EnableServiceMessages = true, // Enables teamcity services messages when logging
/// ReleaseNumber = "1.8.2",
/// DefaultPackageVersion = "1.0.0.0", // All packages in the release should be 1.0.0.0
/// Packages = new Dictionary&lt;string, string&gt;
/// {
/// { "PackageOne", "1.0.2.3" },
/// { "PackageTwo", "5.2.3" }
/// },
/// PackagesFolder = @"C:\MyOtherNugetFeed",
///
/// // One or the other
/// ReleaseNotes = "Version 2.0 \n What a milestone we have ...",
/// ReleaseNotesFile = "./ReleaseNotes.md",
///
/// IgnoreExisting = true // if this release number already exists, ignore it
/// });
/// </code>
/// </example>
public void OctoCreateRelease(System.String projectName, Cake.Common.Tools.OctopusDeploy.CreateReleaseSettings settings)
{
Cake.Common.Tools.OctopusDeploy.OctopusDeployAliases.OctoCreateRelease(Context, projectName, settings);
}
/// <summary>
/// Pushes the specified package to the Octopus Deploy repository
/// </summary>
/// <param name="context">The cake context</param>
/// <param name="server">The Octopus server URL</param>
/// <param name="apiKey">The user's API key</param>
/// <param name="packagePath">Path to the package</param>
/// <param name="settings">The settings</param>
public void OctoPush(System.String server, System.String apiKey, Cake.Core.IO.FilePath packagePath, Cake.Common.Tools.OctopusDeploy.OctopusPushSettings settings)
{
Cake.Common.Tools.OctopusDeploy.OctopusDeployAliases.OctoPush(Context, server, apiKey, packagePath, settings);
}
/// <summary>
/// Pushes the specified packages to the Octopus Deploy repository
/// </summary>
/// <param name="context">The cake context</param>
/// <param name="server">The Octopus server URL</param>
/// <param name="apiKey">The user's API key</param>
/// <param name="packagePaths">Paths to the packages</param>
/// <param name="settings">The settings</param>
public void OctoPush(System.String server, System.String apiKey, System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> packagePaths, Cake.Common.Tools.OctopusDeploy.OctopusPushSettings settings)
{
Cake.Common.Tools.OctopusDeploy.OctopusDeployAliases.OctoPush(Context, server, apiKey, packagePaths, settings);
}
/// <summary>
/// Packs the specified folder into an Octopus Deploy package.
/// </summary>
/// <param name="context">The cake context</param>
/// <param name="id">The package ID.</param>
public void OctoPack(System.String id)
{
Cake.Common.Tools.OctopusDeploy.OctopusDeployAliases.OctoPack(Context, id);
}
/// <summary>
/// Packs the specified folder into an Octopus Deploy package.
/// </summary>
/// <param name="context">The cake context</param>
/// <param name="id">The package ID.</param>
/// <param name="settings">The settings</param>
public void OctoPack(System.String id, Cake.Common.Tools.OctopusDeploy.OctopusPackSettings settings = null)
{
Cake.Common.Tools.OctopusDeploy.OctopusDeployAliases.OctoPack(Context, id, settings);
}
/// <summary>
/// Deploys the specified already existing release into a specified environment
/// See <see href="http://docs.octopusdeploy.com/display/OD/Deploying+releases">Octopus Documentation</see> for more details.
/// </summary>
/// <param name="context">The cake context</param>
/// <param name="server">The Octopus server URL</param>
/// <param name="apiKey">The user's API key</param>
/// <param name="projectName">Name of the target project</param>
/// <param name="deployTo">Target environment name</param>
/// <param name="releaseNumber">Version number of the release to deploy. Specify "latest" for the latest release</param>
/// <param name="settings">Deployment settings</param>
/// <example>
/// <code>
/// // bare minimum
/// OctoDeployRelease("http://octopus-deploy.example", "API-XXXXXXXXXXXXXXXXXXXX", "MyGreatProject", "Testing", "2.1.15-RC" new OctopusDeployReleaseDeploymentSettings());
///
/// // All of deployment arguments
/// OctoDeployRelease("http://octopus-deploy.example", "API-XXXXXXXXXXXXXXXXXXXX", "MyGreatProject", "Testing", "2.1.15-RC" new OctopusDeployReleaseDeploymentSettings {
/// ShowProgress = true,
/// ForcePackageDownload = true,
/// WaitForDeployment = true,
/// DeploymentTimeout = TimeSpan.FromMinutes(1),
/// CancelOnTimeout = true,
/// DeploymentChecksLeepCycle = TimeSpan.FromMinutes(77),
/// GuidedFailure = true,
/// SpecificMachines = new string[] { "Machine1", "Machine2" },
/// Force = true,
/// SkipSteps = new[] { "Step1", "Step2" },
/// NoRawLog = true,
/// RawLogFile = "someFile.txt",
/// DeployAt = new DateTime(2010, 6, 15).AddMinutes(1),
/// Tenant = new[] { "Tenant1", "Tenant2" },
/// TenantTags = new[] { "Tag1", "Tag2" },
/// });
/// </code>
/// </example>
public void OctoDeployRelease(System.String server, System.String apiKey, System.String projectName, System.String deployTo, System.String releaseNumber, Cake.Common.Tools.OctopusDeploy.OctopusDeployReleaseDeploymentSettings settings)
{
Cake.Common.Tools.OctopusDeploy.OctopusDeployAliases.OctoDeployRelease(Context, server, apiKey, projectName, deployTo, releaseNumber, settings);
}
/// <summary>
/// Runs all NUnit unit tests in the assemblies matching the specified pattern.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <example>
/// <code>
/// NUnit3("./src/**/bin/Release/*.Tests.dll");
/// </code>
/// </example>
public void NUnit3(System.String pattern)
{
Cake.Common.Tools.NUnit.NUnit3Aliases.NUnit3(Context, pattern);
}
/// <summary>
/// Runs all NUnit unit tests in the assemblies matching the specified pattern,
/// using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// NUnit3("./src/**/bin/Release/*.Tests.dll", new NUnit3Settings {
/// NoResults = true
/// });
/// </code>
/// </example>
public void NUnit3(System.String pattern, Cake.Common.Tools.NUnit.NUnit3Settings settings)
{
Cake.Common.Tools.NUnit.NUnit3Aliases.NUnit3(Context, pattern, settings);
}
/// <summary>
/// Runs all NUnit unit tests in the specified assemblies.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <example>
/// <code>
/// NUnit3(new [] { "./src/Example.Tests/bin/Release/Example.Tests.dll" });
/// </code>
/// </example>
public void NUnit3(System.Collections.Generic.IEnumerable<System.String> assemblies)
{
Cake.Common.Tools.NUnit.NUnit3Aliases.NUnit3(Context, assemblies);
}
/// <summary>
/// Runs all NUnit unit tests in the specified assemblies.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <example>
/// <code>
/// var testAssemblies = GetFiles("./src/**/bin/Release/*.Tests.dll");
/// NUnit3(testAssemblies);
/// </code>
/// </example>
public void NUnit3(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblies)
{
Cake.Common.Tools.NUnit.NUnit3Aliases.NUnit3(Context, assemblies);
}
/// <summary>
/// Runs all NUnit unit tests in the specified assemblies,
/// using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// NUnit3(new [] { "./src/Example.Tests/bin/Release/Example.Tests.dll" }, new NUnit3Settings {
/// NoResults = true
/// });
/// </code>
/// </example>
public void NUnit3(System.Collections.Generic.IEnumerable<System.String> assemblies, Cake.Common.Tools.NUnit.NUnit3Settings settings)
{
Cake.Common.Tools.NUnit.NUnit3Aliases.NUnit3(Context, assemblies, settings);
}
/// <summary>
/// Runs all NUnit unit tests in the specified assemblies,
/// using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var testAssemblies = GetFiles("./src/**/bin/Release/*.Tests.dll");
/// NUnit3(testAssemblies, new NUnit3Settings {
/// NoResults = true
/// });
/// </code>
/// </example>
public void NUnit3(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblies, Cake.Common.Tools.NUnit.NUnit3Settings settings)
{
Cake.Common.Tools.NUnit.NUnit3Aliases.NUnit3(Context, assemblies, settings);
}
/// <summary>
/// Runs all NUnit unit tests in the assemblies matching the specified pattern.
/// </summary>
/// <example>
/// <code>
/// NUnit("./src/UnitTests/*.dll");
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
public void NUnit(System.String pattern)
{
Cake.Common.Tools.NUnit.NUnitAliases.NUnit(Context, pattern);
}
/// <summary>
/// Runs all NUnit unit tests in the assemblies matching the specified pattern,
/// using the specified settings.
/// </summary>
/// <example>
/// <code>
/// NUnit("./src/UnitTests/*.dll", new NUnitSettings {
/// Timeout = 4000,
/// StopOnError = true
/// });
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="settings">The settings.</param>
public void NUnit(System.String pattern, Cake.Common.Tools.NUnit.NUnitSettings settings)
{
Cake.Common.Tools.NUnit.NUnitAliases.NUnit(Context, pattern, settings);
}
/// <summary>
/// Runs all NUnit unit tests in the specified assemblies.
/// </summary>
/// <example>
/// <code>
/// var assemblies = new [] {
/// "UnitTests1.dll",
/// "UnitTests2.dll"
/// };
/// NUnit(assemblies);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
public void NUnit(System.Collections.Generic.IEnumerable<System.String> assemblies)
{
Cake.Common.Tools.NUnit.NUnitAliases.NUnit(Context, assemblies);
}
/// <summary>
/// Runs all NUnit unit tests in the specified assemblies.
/// </summary>
/// <example>
/// <code>
/// var assemblies = GetFiles("./src/UnitTests/*.dll");
/// NUnit(assemblies);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
public void NUnit(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblies)
{
Cake.Common.Tools.NUnit.NUnitAliases.NUnit(Context, assemblies);
}
/// <summary>
/// Runs all NUnit unit tests in the specified assemblies,
/// using the specified settings.
/// </summary>
/// <example>
/// <code>
/// var assemblies = new [] {
/// "UnitTests1.dll",
/// "UnitTests2.dll"
/// };
/// NUnit(assemblies, new NUnitSettings {
/// Timeout = 4000,
/// StopOnError = true
/// });
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <param name="settings">The settings.</param>
public void NUnit(System.Collections.Generic.IEnumerable<System.String> assemblies, Cake.Common.Tools.NUnit.NUnitSettings settings)
{
Cake.Common.Tools.NUnit.NUnitAliases.NUnit(Context, assemblies, settings);
}
/// <summary>
/// Runs all NUnit unit tests in the specified assemblies,
/// using the specified settings.
/// </summary>
/// <example>
/// <code>
/// var assemblies = GetFiles(""./src/UnitTests/*.dll"");
/// NUnit(assemblies, new NUnitSettings {
/// Timeout = 4000,
/// StopOnError = true
/// });
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <param name="settings">The settings.</param>
public void NUnit(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblies, Cake.Common.Tools.NUnit.NUnitSettings settings)
{
Cake.Common.Tools.NUnit.NUnitAliases.NUnit(Context, assemblies, settings);
}
/// <summary>
/// Creates a NuGet package using the specified Nuspec or project file.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The nuspec or project file path.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var nuGetPackSettings = new NuGetPackSettings {
/// Id = "TestNuget",
/// Version = "0.0.0.1",
/// Title = "The tile of the package",
/// Authors = new[] {"John Doe"},
/// Owners = new[] {"Contoso"},
/// Description = "The description of the package",
/// Summary = "Excellent summary of what the package does",
/// ProjectUrl = new Uri("https://github.com/SomeUser/TestNuget/"),
/// IconUrl = new Uri("http://cdn.rawgit.com/SomeUser/TestNuget/master/icons/testnuget.png"),
/// LicenseUrl = new Uri("https://github.com/SomeUser/TestNuget/blob/master/LICENSE.md"),
/// Copyright = "Some company 2015",
/// ReleaseNotes = new [] {"Bug fixes", "Issue fixes", "Typos"},
/// Tags = new [] {"Cake", "Script", "Build"},
/// RequireLicenseAcceptance= false,
/// Symbols = false,
/// NoPackageAnalysis = true,
/// Files = new [] {
/// new NuSpecContent {Source = "bin/TestNuget.dll", Target = "bin"},
/// },
/// BasePath = "./src/TestNuget/bin/release",
/// OutputDirectory = "./nuget"
/// };
///
/// NuGetPack("./nuspec/TestNuget.nuspec", nuGetPackSettings);
/// </code>
/// </example>
public void NuGetPack(Cake.Core.IO.FilePath filePath, Cake.Common.Tools.NuGet.Pack.NuGetPackSettings settings)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetPack(Context, filePath, settings);
}
/// <summary>
/// Creates NuGet packages using the specified Nuspec or project files.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="filePaths">The nuspec or project file paths.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var nuGetPackSettings = new NuGetPackSettings {
/// Id = "TestNuget",
/// Version = "0.0.0.1",
/// Title = "The tile of the package",
/// Authors = new[] {"John Doe"},
/// Owners = new[] {"Contoso"},
/// Description = "The description of the package",
/// Summary = "Excellent summary of what the package does",
/// ProjectUrl = new Uri("https://github.com/SomeUser/TestNuget/"),
/// IconUrl = new Uri("http://cdn.rawgit.com/SomeUser/TestNuget/master/icons/testnuget.png"),
/// LicenseUrl = new Uri("https://github.com/SomeUser/TestNuget/blob/master/LICENSE.md"),
/// Copyright = "Some company 2015",
/// ReleaseNotes = new [] {"Bug fixes", "Issue fixes", "Typos"},
/// Tags = new [] {"Cake", "Script", "Build"},
/// RequireLicenseAcceptance= false,
/// Symbols = false,
/// NoPackageAnalysis = true,
/// Files = new [] {
/// new NuSpecContent {Source = "bin/TestNuget.dll", Target = "bin"},
/// },
/// BasePath = "./src/TestNuget/bin/release",
/// OutputDirectory = "./nuget"
/// };
///
/// var nuspecFiles = GetFiles("./**/*.nuspec");
/// NuGetPack(nuspecFiles, nuGetPackSettings);
/// </code>
/// </example>
public void NuGetPack(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> filePaths, Cake.Common.Tools.NuGet.Pack.NuGetPackSettings settings)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetPack(Context, filePaths, settings);
}
/// <summary>
/// Creates a NuGet package using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var nuGetPackSettings = new NuGetPackSettings {
/// Id = "TestNuget",
/// Version = "0.0.0.1",
/// Title = "The tile of the package",
/// Authors = new[] {"John Doe"},
/// Owners = new[] {"Contoso"},
/// Description = "The description of the package",
/// Summary = "Excellent summary of what the package does",
/// ProjectUrl = new Uri("https://github.com/SomeUser/TestNuget/"),
/// IconUrl = new Uri("http://cdn.rawgit.com/SomeUser/TestNuget/master/icons/testnuget.png"),
/// LicenseUrl = new Uri("https://github.com/SomeUser/TestNuget/blob/master/LICENSE.md"),
/// Copyright = "Some company 2015",
/// ReleaseNotes = new [] {"Bug fixes", "Issue fixes", "Typos"},
/// Tags = new [] {"Cake", "Script", "Build"},
/// RequireLicenseAcceptance= false,
/// Symbols = false,
/// NoPackageAnalysis = true,
/// Files = new [] {
/// new NuSpecContent {Source = "bin/TestNuget.dll", Target = "bin"},
/// },
/// BasePath = "./src/TestNuget/bin/release",
/// OutputDirectory = "./nuget"
/// };
///
/// NuGetPack(nuGetPackSettings);
/// </code>
/// </example>
public void NuGetPack(Cake.Common.Tools.NuGet.Pack.NuGetPackSettings settings)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetPack(Context, settings);
}
/// <summary>
/// Restores NuGet packages for the specified target.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="targetFilePath">The target to restore.</param>
/// <example>
/// <code>
/// var solutions = GetFiles("./**/*.sln");
/// // Restore all NuGet packages.
/// foreach(var solution in solutions)
/// {
/// Information("Restoring {0}", solution);
/// NuGetRestore(solution);
/// }
/// </code>
/// </example>
public void NuGetRestore(Cake.Core.IO.FilePath targetFilePath)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetRestore(Context, targetFilePath);
}
/// <summary>
/// Restores NuGet packages for the specified targets.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="targetFilePaths">The targets to restore.</param>
/// <example>
/// <code>
/// var solutions = GetFiles("./**/*.sln");
/// NuGetRestore(solutions);
/// </code>
/// </example>
public void NuGetRestore(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> targetFilePaths)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetRestore(Context, targetFilePaths);
}
/// <summary>
/// Restores NuGet packages using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="targetFilePath">The target to restore.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var solutions = GetFiles("./**/*.sln");
/// // Restore all NuGet packages.
/// foreach(var solution in solutions)
/// {
/// Information("Restoring {0}", solution);
/// NuGetRestore(solution, new NuGetRestoreSettings { NoCache = true });
/// }
/// </code>
/// </example>
public void NuGetRestore(Cake.Core.IO.FilePath targetFilePath, Cake.Common.Tools.NuGet.Restore.NuGetRestoreSettings settings)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetRestore(Context, targetFilePath, settings);
}
/// <summary>
/// Restores NuGet packages using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="targetFilePaths">The targets to restore.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var solutions = GetFiles("./**/*.sln");
/// NuGetRestore(solutions, new NuGetRestoreSettings { NoCache = true });
/// </code>
/// </example>
public void NuGetRestore(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> targetFilePaths, Cake.Common.Tools.NuGet.Restore.NuGetRestoreSettings settings)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetRestore(Context, targetFilePaths, settings);
}
/// <summary>
/// Pushes a NuGet package to a NuGet server and publishes it.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageFilePath">The <c>.nupkg</c> file path.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <para>NOTE: Starting with NuGet 3.4.2, the Source parameter is a mandatory parameter.</para>
/// <para>It is strongly recommended that you ALWAYS set the Source property within the <see cref="T:Cake.Common.Tools.NuGet.Push.NuGetPushSettings" /> instance.</para>
/// <code>
/// // Get the path to the package.
/// var package = "./nuget/SlackPRTGCommander.0.0.1.nupkg";
///
/// // Push the package.
/// NuGetPush(package, new NuGetPushSettings {
/// Source = "http://example.com/nugetfeed",
/// ApiKey = "4003d786-cc37-4004-bfdf-c4f3e8ef9b3a"
/// });
/// </code>
/// </example>
public void NuGetPush(Cake.Core.IO.FilePath packageFilePath, Cake.Common.Tools.NuGet.Push.NuGetPushSettings settings)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetPush(Context, packageFilePath, settings);
}
/// <summary>
/// Pushes NuGet packages to a NuGet server and publishes them.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageFilePaths">The <c>.nupkg</c> file paths.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <para>NOTE: Starting with NuGet 3.4.2, the Source parameter is a mandatory parameter.</para>
/// <para>It is strongly recommended that you ALWAYS set the Source property within the <see cref="T:Cake.Common.Tools.NuGet.Push.NuGetPushSettings" /> instance.</para>
/// <code>
/// // Get the paths to the packages.
/// var packages = GetFiles("./**/*.nupkg");
///
/// // Push the package.
/// NuGetPush(packages, new NuGetPushSettings {
/// Source = "http://example.com/nugetfeed",
/// ApiKey = "4003d786-cc37-4004-bfdf-c4f3e8ef9b3a"
/// });
/// </code>
/// </example>
public void NuGetPush(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> packageFilePaths, Cake.Common.Tools.NuGet.Push.NuGetPushSettings settings)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetPush(Context, packageFilePaths, settings);
}
/// <summary>
/// Adds NuGet package source using the specified name &amp;source to global user config
/// </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the source.</param>
/// <param name="source">Path to the package(s) source.</param>
/// <example>
/// <code>
/// var feed = new
/// {
/// Name = EnvironmentVariable("PUBLIC_FEED_NAME"),
/// Source = EnvironmentVariable("PUBLIC_FEED_SOURCE")
/// };
///
/// NuGetAddSource(
/// name:feed.Name,
/// source:feed.Source
/// );
/// </code>
/// </example>
public void NuGetAddSource(System.String name, System.String source)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetAddSource(Context, name, source);
}
/// <summary>
/// Adds NuGet package source using the specified name, source &amp; settings to global user config
/// </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the source.</param>
/// <param name="source">Path to the package(s) source.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var nugetSourceSettings = new NuGetSourcesSettings
/// {
/// UserName = EnvironmentVariable("PRIVATE_FEED_USERNAME"),
/// Password = EnvironmentVariable("PRIVATE_FEED_PASSWORD"),
/// IsSensitiveSource = true,
/// Verbosity = NuGetVerbosity.Detailed
/// };
///
/// var feed = new
/// {
/// Name = EnvironmentVariable("PRIVATE_FEED_NAME"),
/// Source = EnvironmentVariable("PRIVATE_FEED_SOURCE")
/// };
///
/// NuGetAddSource(
/// name:feed.Name,
/// source:feed.Source,
/// settings:nugetSourceSettings
/// );
/// </code>
/// </example>
public void NuGetAddSource(System.String name, System.String source, Cake.Common.Tools.NuGet.Sources.NuGetSourcesSettings settings)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetAddSource(Context, name, source, settings);
}
/// <summary>
/// Removes NuGet package source using the specified name &amp; source from global user config
/// </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the source.</param>
/// <param name="source">Path to the package(s) source.</param>
/// <example>
/// <code>
/// var feed = new
/// {
/// Name = EnvironmentVariable("PRIVATE_FEED_NAME"),
/// Source = EnvironmentVariable("PRIVATE_FEED_SOURCE")
/// };
///
/// NuGetRemoveSource(
/// name:feed.Name,
/// source:feed.Source
/// );
/// </code>
/// </example>
public void NuGetRemoveSource(System.String name, System.String source)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetRemoveSource(Context, name, source);
}
/// <summary>
/// Removes NuGet package source using the specified name, source &amp; settings from global user config
/// </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the source.</param>
/// <param name="source">Path to the package(s) source.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var nugetSourceSettings = new NuGetSourcesSettings
/// {
/// UserName = EnvironmentVariable("PRIVATE_FEED_USERNAME"),
/// Password = EnvironmentVariable("PRIVATE_FEED_PASSWORD"),
/// IsSensitiveSource = true,
/// Verbosity = NuGetVerbosity.Detailed
/// };
///
/// var feed = new
/// {
/// Name = EnvironmentVariable("PRIVATE_FEED_NAME"),
/// Source = EnvironmentVariable("PRIVATE_FEED_SOURCE")
/// };
///
/// NuGetRemoveSource(
/// name:feed.Name,
/// source:feed.Source,
/// settings:nugetSourceSettings
/// );
/// </code>
/// </example>
public void NuGetRemoveSource(System.String name, System.String source, Cake.Common.Tools.NuGet.Sources.NuGetSourcesSettings settings)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetRemoveSource(Context, name, source, settings);
}
/// <summary>
/// Checks whether or not a NuGet package source exists in the global user configuration, using the specified source.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="source">Path to the package(s) source.</param>
/// <returns>Whether or not the NuGet package source exists in the global user configuration.</returns>
/// <example>
/// <code>
/// var feed = new
/// {
/// Name = EnvironmentVariable("PRIVATE_FEED_NAME"),
/// Source = EnvironmentVariable("PRIVATE_FEED_SOURCE")
/// };
/// if (!NuGetHasSource(source:feed.Source))
/// {
/// Information("Source missing");
/// }
/// else
/// {
/// Information("Source already exists");
/// }
/// </code>
/// </example>
public System.Boolean NuGetHasSource(System.String source)
{
return Cake.Common.Tools.NuGet.NuGetAliases.NuGetHasSource(Context, source);
}
/// <summary>
/// Checks whether or not a NuGet package source exists in the global user configuration, using the specified source and settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="source">Path to the package(s) source.</param>
/// <param name="settings">The settings.</param>
/// <returns>Whether the specified NuGet package source exist.</returns>
/// <example>
/// <code>
/// var nugetSourceSettings = new NuGetSourcesSettings
/// {
/// UserName = EnvironmentVariable("PRIVATE_FEED_USERNAME"),
/// Password = EnvironmentVariable("PRIVATE_FEED_PASSWORD"),
/// IsSensitiveSource = true,
/// Verbosity = NuGetVerbosity.Detailed
/// };
/// var feed = new
/// {
/// Name = EnvironmentVariable("PRIVATE_FEED_NAME"),
/// Source = EnvironmentVariable("PRIVATE_FEED_SOURCE")
/// };
/// if (!NuGetHasSource(
/// source:feed.Source,
/// settings:nugetSourceSettings))
/// {
/// Information("Source missing");
/// }
/// else
/// {
/// Information("Source already exists");
/// }
/// </code>
/// </example>
public System.Boolean NuGetHasSource(System.String source, Cake.Common.Tools.NuGet.Sources.NuGetSourcesSettings settings)
{
return Cake.Common.Tools.NuGet.NuGetAliases.NuGetHasSource(Context, source, settings);
}
/// <summary>
/// Installs a NuGet package.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to install.</param>
/// <example>
/// <code>
/// NuGetInstall("MyNugetPackage");
/// </code>
/// </example>
public void NuGetInstall(System.String packageId)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetInstall(Context, packageId);
}
/// <summary>
/// Installs NuGet packages.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageIds">The id's of the package to install.</param>
/// <example>
/// <code>
/// NuGetInstall(new[] { "MyNugetPackage", "OtherNugetPackage" });
/// </code>
/// </example>
public void NuGetInstall(System.Collections.Generic.IEnumerable<System.String> packageIds)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetInstall(Context, packageIds);
}
/// <summary>
/// Installs a NuGet package using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to install.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// NuGetInstall("MyNugetPackage", new NuGetInstallSettings {
/// ExcludeVersion = true,
/// OutputDirectory = "./tools"
/// });
/// </code>
/// </example>
public void NuGetInstall(System.String packageId, Cake.Common.Tools.NuGet.Install.NuGetInstallSettings settings)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetInstall(Context, packageId, settings);
}
/// <summary>
/// Installs NuGet packages using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageIds">The id's of the package to install.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// NuGetInstall(new[] { "MyNugetPackage", "OtherNugetPackage" }, new NuGetInstallSettings {
/// ExcludeVersion = true,
/// OutputDirectory = "./tools"
/// });
/// </code>
/// </example>
public void NuGetInstall(System.Collections.Generic.IEnumerable<System.String> packageIds, Cake.Common.Tools.NuGet.Install.NuGetInstallSettings settings)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetInstall(Context, packageIds, settings);
}
/// <summary>
/// Installs NuGet packages using the specified package configuration.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageConfigPath">The package configuration to install.</param>
/// <example>
/// <code>
/// NuGetInstallFromConfig("./tools/packages.config");
/// </code>
/// </example>
public void NuGetInstallFromConfig(Cake.Core.IO.FilePath packageConfigPath)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetInstallFromConfig(Context, packageConfigPath);
}
/// <summary>
/// Installs NuGet packages using the specified package configurations.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageConfigPaths">The package configurations to install.</param>
/// <example>
/// <code>
/// var packageConfigs = GetFiles("./**/packages.config");
///
/// NuGetInstallFromConfig(packageConfigs);
/// </code>
/// </example>
public void NuGetInstallFromConfig(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> packageConfigPaths)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetInstallFromConfig(Context, packageConfigPaths);
}
/// <summary>
/// Installs NuGet packages using the specified package configuration and settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageConfigPath">The package configuration to install.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// NuGetInstallFromConfig("./tools/packages.config", new NuGetInstallSettings {
/// ExcludeVersion = true,
/// OutputDirectory = "./tools"
/// });
/// </code>
/// </example>
public void NuGetInstallFromConfig(Cake.Core.IO.FilePath packageConfigPath, Cake.Common.Tools.NuGet.Install.NuGetInstallSettings settings)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetInstallFromConfig(Context, packageConfigPath, settings);
}
/// <summary>
/// Installs NuGet packages using the specified package configurations and settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageConfigPaths">The package configurations to install.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var packageConfigs = GetFiles("./**/packages.config");
///
/// NuGetInstallFromConfig(packageConfigs, new NuGetInstallSettings {
/// ExcludeVersion = true,
/// OutputDirectory = "./tools"
/// });
/// </code>
/// </example>
public void NuGetInstallFromConfig(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> packageConfigPaths, Cake.Common.Tools.NuGet.Install.NuGetInstallSettings settings)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetInstallFromConfig(Context, packageConfigPaths, settings);
}
/// <summary>
/// Installs NuGet packages using the specified API key, source and settings.
/// </summary>
/// <example>
/// <code>
/// var setting = new NuGetSetApiKeySettings {
/// Verbosity = NuGetVerbosity.Detailed
/// };
/// NuGetSetApiKey("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", "https://nuget.org/api/v2/", setting);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="apiKey">The API key.</param>
/// <param name="source">Server URL where the API key is valid.</param>
/// <param name="settings">The settings.</param>
public void NuGetSetApiKey(System.String apiKey, System.String source, Cake.Common.Tools.NuGet.SetApiKey.NuGetSetApiKeySettings settings)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetSetApiKey(Context, apiKey, source, settings);
}
/// <summary>
/// Installs NuGet packages using the specified API key and source.
/// </summary>
/// <example>
/// <code>
/// NuGetSetApiKey("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", "https://nuget.org/api/v2/");
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="apiKey">The API key.</param>
/// <param name="source">Server URL where the API key is valid.</param>
public void NuGetSetApiKey(System.String apiKey, System.String source)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetSetApiKey(Context, apiKey, source);
}
/// <summary>
/// Set the proxy settings to be used while connecting to your NuGet feed, including settings.
/// </summary>
/// <example>
/// <code>
/// var setting = new NuGetSetProxySettings {
/// Verbosity = NuGetVerbosity.Detailed
/// };
/// NuGetSetProxy("127.0.0.1:8080", "proxyuser","Pa$$w0rd1", setting);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="proxy">The url of the proxy.</param>
/// <param name="username">The username used to access the proxy.</param>
/// <param name="password">The password used to access the proxy.</param>
/// <param name="settings">The settings.</param>
public void NuGetSetProxy(System.String proxy, System.String username, System.String password, Cake.Common.Tools.NuGet.SetProxy.NuGetSetProxySettings settings)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetSetProxy(Context, proxy, username, password, settings);
}
/// <summary>
/// Set the proxy settings to be used while connecting to your NuGet feed.
/// </summary>
/// <example>
/// <code>
/// NuGetSetProxy("127.0.0.1:8080", "proxyuser","Pa$$w0rd1");
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="proxy">The url of the proxy.</param>
/// <param name="username">The username used to access the proxy.</param>
/// <param name="password">The password used to access the proxy.</param>
public void NuGetSetProxy(System.String proxy, System.String username, System.String password)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetSetProxy(Context, proxy, username, password);
}
/// <summary>
/// Updates NuGet packages.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="targetFile">The target to update.</param>
/// <example>
/// <code>
/// NuGetUpdate("./tools/packages.config");
/// </code>
/// </example>
public void NuGetUpdate(Cake.Core.IO.FilePath targetFile)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetUpdate(Context, targetFile);
}
/// <summary>
/// Updates NuGet packages.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="targetFiles">The targets to update.</param>
/// <example>
/// <code>
/// var targets = GetFiles("./**/packages.config");
///
/// NuGetUpdate(targets);
/// </code>
/// </example>
public void NuGetUpdate(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> targetFiles)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetUpdate(Context, targetFiles);
}
/// <summary>
/// Updates NuGet packages using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="targetFile">The target to update.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// NuGetUpdate("./tools/packages.config", new NuGetUpdateSettings {
/// Prerelease = true,
/// });
/// </code>
/// </example>
public void NuGetUpdate(Cake.Core.IO.FilePath targetFile, Cake.Common.Tools.NuGet.Update.NuGetUpdateSettings settings)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetUpdate(Context, targetFile, settings);
}
/// <summary>
/// Updates NuGet packages using the specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="targetFiles">The targets to update.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var targets = GetFiles("./**/packages.config");
///
/// NuGetUpdate(targets, new NuGetUpdateSettings {
/// Prerelease = true,
/// });
/// </code>
/// </example>
public void NuGetUpdate(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> targetFiles, Cake.Common.Tools.NuGet.Update.NuGetUpdateSettings settings)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetUpdate(Context, targetFiles, settings);
}
/// <summary>
/// Adds a NuGet package using package id and source.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to add.</param>
/// <param name="source">Path to the local feed source.</param>
/// <example>
/// <code>
/// NuGetAdd("MyNugetPackage", "//bar/packages/");
/// </code>
/// </example>
public void NuGetAdd(System.String packageId, System.String source)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetAdd(Context, packageId, source);
}
/// <summary>
/// Adds a NuGet package using package id and source.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to add.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// NuGetAdd("MyNugetPackage", new NuGetAddSettings({
/// Source = "//bar/packages/"
/// });
/// </code>
/// </example>
public void NuGetAdd(System.String packageId, Cake.Common.Tools.NuGet.Add.NuGetAddSettings settings)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetAdd(Context, packageId, settings);
}
/// <summary>
/// Adds all packages from source to destination.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="source">The local feed package source.</param>
/// <param name="destination">The local feed destination source.</param>
/// <example>
/// <code>
/// NuGetInit("//foo/packages", "//bar/packages/");
/// </code>
/// </example>
public void NuGetInit(System.String source, System.String destination)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetInit(Context, source, destination);
}
/// <summary>
/// Adds all packages from source to destination using specified settings.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="source">The local feed package source.</param>
/// <param name="destination">The local feed destination source.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// NuGetInit("//foo/packages", "//bar/packages/", new NuGetInitSettings {
/// Expand = true
/// });
/// </code>
/// </example>
public void NuGetInit(System.String source, System.String destination, Cake.Common.Tools.NuGet.Init.NuGetInitSettings settings)
{
Cake.Common.Tools.NuGet.NuGetAliases.NuGetInit(Context, source, destination, settings);
}
/// <summary>
/// List packages on available from source using specified settings
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The package Id</param>
/// <param name="settings">The settings.</param>
/// <returns>List of packages with their version</returns>
/// <example>
/// <code>
/// var packageList = NuGetList("Cake", new NuGetListSettings {
/// AllVersions = false,
/// Prerelease = false
/// });
/// foreach(var package in packageList)
/// {
/// Information("Found package {0}, version {1}", package.Name, package.Version);
/// }
/// </code>
/// </example>
public System.Collections.Generic.IEnumerable<Cake.Common.Tools.NuGet.List.NuGetListItem> NuGetList(System.String packageId, Cake.Common.Tools.NuGet.List.NuGetListSettings settings)
{
return Cake.Common.Tools.NuGet.NuGetAliases.NuGetList(Context, packageId, settings);
}
/// <summary>
/// List packages on available from source using specified settings
/// </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The package Id</param>
/// <returns>List of packages with their version</returns>
/// <example>
/// <code>
/// var packageList = NuGetList("Cake");
/// foreach(var package in packageList)
/// {
/// Information("Found package {0}, version {1}", package.Name, package.Version);
/// }
/// </code>
/// </example>
public System.Collections.Generic.IEnumerable<Cake.Common.Tools.NuGet.List.NuGetListItem> NuGetList(System.String packageId)
{
return Cake.Common.Tools.NuGet.NuGetAliases.NuGetList(Context, packageId);
}
/// <summary>
/// List packages on available from source using specified settings
/// </summary>
/// <param name="context">The context.</param>
/// <param name="settings">The settings.</param>
/// <returns>List of packages with their version</returns>
/// <example>
/// <code>
/// var packageList = NuGetList(new NuGetListSettings {
/// AllVersions = false,
/// Prerelease = false
/// });
/// foreach(var package in packageList)
/// {
/// Information("Found package {0}, version {1}", package.Name, package.Version);
/// }
/// </code>
/// </example>
public System.Collections.Generic.IEnumerable<Cake.Common.Tools.NuGet.List.NuGetListItem> NuGetList(Cake.Common.Tools.NuGet.List.NuGetListSettings settings)
{
return Cake.Common.Tools.NuGet.NuGetAliases.NuGetList(Context, settings);
}
/// <summary>
/// Runs all MSTest unit tests in the assemblies matching the specified pattern.
/// </summary>
/// <example>
/// <code>
/// MSTest("./Tests/*.UnitTests.dll");
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
public void MSTest(System.String pattern)
{
Cake.Common.Tools.MSTest.MSTestAliases.MSTest(Context, pattern);
}
/// <summary>
/// Runs all MSTest unit tests in the assemblies matching the specified pattern.
/// </summary>
/// <example>
/// <code>
/// MSTest("./Tests/*.UnitTests.dll", new MSTestSettings() { NoIsolation = false });
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="settings">The settings.</param>
public void MSTest(System.String pattern, Cake.Common.Tools.MSTest.MSTestSettings settings)
{
Cake.Common.Tools.MSTest.MSTestAliases.MSTest(Context, pattern, settings);
}
/// <summary>
/// Runs all MSTest unit tests in the specified assemblies.
/// </summary>
/// <example>
/// <code>
/// var paths = new List&lt;FilePath&gt;() { "./assemblydir1", "./assemblydir2" };
/// MSTest(paths);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="assemblyPaths">The assembly paths.</param>
public void MSTest(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblyPaths)
{
Cake.Common.Tools.MSTest.MSTestAliases.MSTest(Context, assemblyPaths);
}
/// <summary>
/// Runs all MSTest unit tests in the specified assemblies.
/// </summary>
/// <example>
/// <code>
/// var paths = new List&lt;FilePath&gt;() { "./assemblydir1", "./assemblydir2" };
/// MSTest(paths, new MSTestSettings() { NoIsolation = false });
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="assemblyPaths">The assembly paths.</param>
/// <param name="settings">The settings.</param>
public void MSTest(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblyPaths, Cake.Common.Tools.MSTest.MSTestSettings settings)
{
Cake.Common.Tools.MSTest.MSTestAliases.MSTest(Context, assemblyPaths, settings);
}
/// <summary>
/// Builds the specified solution using MSBuild.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="solution">The solution.</param>
/// <example>
/// <code>
/// MSBuild("./src/Cake.sln");
/// </code>
/// </example>
public void MSBuild(Cake.Core.IO.FilePath solution)
{
Cake.Common.Tools.MSBuild.MSBuildAliases.MSBuild(Context, solution);
}
/// <summary>
/// Builds the specified solution using MSBuild.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="solution">The solution to build.</param>
/// <param name="configurator">The settings configurator.</param>
/// <example>
/// <code>
/// MSBuild("./src/Cake.sln", configurator =&gt;
/// configurator.SetConfiguration("Debug")
/// .SetVerbosity(Verbosity.Minimal)
/// .UseToolVersion(MSBuildToolVersion.VS2015)
/// .SetMSBuildPlatform(MSBuildPlatform.x86)
/// .SetPlatformTarget(PlatformTarget.MSIL));
/// </code>
/// </example>
public void MSBuild(Cake.Core.IO.FilePath solution, System.Action<Cake.Common.Tools.MSBuild.MSBuildSettings> configurator)
{
Cake.Common.Tools.MSBuild.MSBuildAliases.MSBuild(Context, solution, configurator);
}
/// <summary>
/// Builds the specified solution using MSBuild.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="solution">The solution to build.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// MSBuild("./src/Cake.sln", new MSBuildSettings {
/// Verbosity = Verbosity.Minimal,
/// ToolVersion = MSBuildToolVersion.VS2015,
/// Configuration = "Release",
/// PlatformTarget = PlatformTarget.MSIL
/// });
/// </code>
/// </example>
public void MSBuild(Cake.Core.IO.FilePath solution, Cake.Common.Tools.MSBuild.MSBuildSettings settings)
{
Cake.Common.Tools.MSBuild.MSBuildAliases.MSBuild(Context, solution, settings);
}
/// <summary>
/// Merges the specified assemblies.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="outputFile">The output file.</param>
/// <param name="primaryAssembly">The primary assembly.</param>
/// <param name="assemblyPaths">The assembly paths.</param>
/// <example>
/// <code>
/// var assemblyPaths = GetFiles("./**/Cake.*.dll");
/// ILMerge("./MergedCake.exe", "./Cake.exe", assemblyPaths);
/// </code>
/// </example>
public void ILMerge(Cake.Core.IO.FilePath outputFile, Cake.Core.IO.FilePath primaryAssembly, System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblyPaths)
{
Cake.Common.Tools.ILMerge.ILMergeAliases.ILMerge(Context, outputFile, primaryAssembly, assemblyPaths);
}
/// <summary>
/// Merges the specified assemblies.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="outputFile">The output file.</param>
/// <param name="primaryAssembly">The primary assembly.</param>
/// <param name="assemblyPaths">The assembly paths.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var assemblyPaths = GetFiles("./**/Cake.*.dll");
/// ILMerge(
/// "./MergedCake.exe",
/// "./Cake.exe",
/// assemblyPaths,
/// new ILMergeSettings { Internalize = true });
/// </code>
/// </example>
public void ILMerge(Cake.Core.IO.FilePath outputFile, Cake.Core.IO.FilePath primaryAssembly, System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblyPaths, Cake.Common.Tools.ILMerge.ILMergeSettings settings)
{
Cake.Common.Tools.ILMerge.ILMergeAliases.ILMerge(Context, outputFile, primaryAssembly, assemblyPaths, settings);
}
/// <summary>
/// Executes cake script out of process
/// </summary>
/// <param name="context">The context.</param>
/// <param name="cakeScriptPath">The script file.</param>
/// <example>
/// <code>
/// CakeExecuteScript("./helloworld.cake");
/// </code>
/// </example>
public void CakeExecuteScript(Cake.Core.IO.FilePath cakeScriptPath)
{
Cake.Common.Tools.Cake.CakeAliases.CakeExecuteScript(Context, cakeScriptPath);
}
/// <summary>
/// Executes cake script out of process
/// </summary>
/// <param name="context">The context.</param>
/// <param name="cakeScriptPath">The script file.</param>
/// <param name="settings">The settings <see cref="T:Cake.Common.Tools.Cake.CakeSettings" />.</param>
/// <example>
/// <code>
/// CakeExecuteScript("./helloworld.cake", new CakeSettings{ ToolPath="./Cake.exe" });
/// </code>
/// </example>
public void CakeExecuteScript(Cake.Core.IO.FilePath cakeScriptPath, Cake.Common.Tools.Cake.CakeSettings settings)
{
Cake.Common.Tools.Cake.CakeAliases.CakeExecuteScript(Context, cakeScriptPath, settings);
}
/// <summary>
/// Executes Cake expression out of process
/// </summary>
/// <param name="context">The context.</param>
/// <param name="cakeExpression">The cake expression</param>
/// <example>
/// <code>
/// CakeExecuteExpression("Information(\"Hello {0}\", \"World\");");
/// </code>
/// </example>
public void CakeExecuteExpression(System.String cakeExpression)
{
Cake.Common.Tools.Cake.CakeAliases.CakeExecuteExpression(Context, cakeExpression);
}
/// <summary>
/// Executes Cake expression out of process
/// </summary>
/// <param name="context">The context.</param>
/// <param name="cakeExpression">The cake expression</param>
/// <param name="settings">The settings <see cref="T:Cake.Common.Tools.Cake.CakeSettings" />.</param>
/// <example>
/// <code>
/// CakeExecuteExpression(
/// "Information(\"Hello {0}!\", Argument&lt;string&gt;(\"name\"));",
/// new CakeSettings {
/// ToolPath="./Cake.exe" ,
/// Arguments = new Dictionary&lt;string, string&gt;{{"name", "World"}}
/// });
/// </code>
/// </example>
public void CakeExecuteExpression(System.String cakeExpression, Cake.Common.Tools.Cake.CakeSettings settings)
{
Cake.Common.Tools.Cake.CakeAliases.CakeExecuteExpression(Context, cakeExpression, settings);
}
/// <summary>
/// Creates a text transformation from the provided template.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="template">The template.</param>
/// <returns>A <see cref="T:Cake.Common.Text.TextTransformation`1" /> representing the provided template.</returns>
/// <example>
/// This sample shows how to create a <see cref="T:Cake.Common.Text.TextTransformation`1" /> using
/// the specified template.
/// <code>
/// string text = TransformText("Hello &lt;%subject%&gt;!")
/// .WithToken("subject", "world")
/// .ToString();
/// </code>
/// </example>
public Cake.Common.Text.TextTransformation<Cake.Core.Text.TextTransformationTemplate> TransformText(System.String template)
{
return Cake.Common.Text.TextTransformationAliases.TransformText(Context, template);
}
/// <summary>
/// Creates a text transformation from the provided template, using the specified placeholder.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="template">The template.</param>
/// <param name="leftPlaceholder">The left placeholder.</param>
/// <param name="rightPlaceholder">The right placeholder.</param>
/// <returns>A <see cref="T:Cake.Common.Text.TextTransformation`1" /> representing the provided template.</returns>
/// <example>
/// This sample shows how to create a <see cref="T:Cake.Common.Text.TextTransformation`1" /> using
/// the specified template and placeholder.
/// <code>
/// string text = TransformText("Hello {subject}!", "{", "}")
/// .WithToken("subject", "world")
/// .ToString();
/// </code>
/// </example>
public Cake.Common.Text.TextTransformation<Cake.Core.Text.TextTransformationTemplate> TransformText(System.String template, System.String leftPlaceholder, System.String rightPlaceholder)
{
return Cake.Common.Text.TextTransformationAliases.TransformText(Context, template, leftPlaceholder, rightPlaceholder);
}
/// <summary>
/// Creates a text transformation from the provided template on disc.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="path">The template file path.</param>
/// <returns>A <see cref="T:Cake.Common.Text.TextTransformation`1" /> representing the provided template.</returns>
/// <example>
/// This sample shows how to create a <see cref="T:Cake.Common.Text.TextTransformation`1" /> using
/// the specified template file with the placeholder format <c>&lt;%key%&gt;</c>.
/// <code>
/// string text = TransformTextFile("./template.txt")
/// .WithToken("subject", "world")
/// .ToString();
/// </code>
/// </example>
public Cake.Common.Text.TextTransformation<Cake.Core.Text.TextTransformationTemplate> TransformTextFile(Cake.Core.IO.FilePath path)
{
return Cake.Common.Text.TextTransformationAliases.TransformTextFile(Context, path);
}
/// <summary>
/// Creates a text transformation from the provided template on disc, using the specified placeholder.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="path">The template file path.</param>
/// <param name="leftPlaceholder">The left placeholder.</param>
/// <param name="rightPlaceholder">The right placeholder.</param>
/// <returns>A <see cref="T:Cake.Common.Text.TextTransformation`1" /> representing the provided template.</returns>
/// <example>
/// This sample shows how to create a <see cref="T:Cake.Common.Text.TextTransformation`1" /> using
/// the specified template file and placeholder.
/// <code>
/// string text = TransformTextFile("./template.txt", "{", "}")
/// .WithToken("subject", "world")
/// .ToString();
/// </code>
/// </example>
public Cake.Common.Text.TextTransformation<Cake.Core.Text.TextTransformationTemplate> TransformTextFile(Cake.Core.IO.FilePath path, System.String leftPlaceholder, System.String rightPlaceholder)
{
return Cake.Common.Text.TextTransformationAliases.TransformTextFile(Context, path, leftPlaceholder, rightPlaceholder);
}
/// <summary>
/// Parses project information from a solution file.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="solutionPath">The solution path.</param>
/// <returns>A parsed solution.</returns>
/// <example>
/// <code>
/// var solutionPath = "./src/Cake.sln";
/// Information("Parsing {0}", solutionPath);
/// var parsedSolution = ParseSolution(solutionPath);
/// foreach(var project in parsedSolution.Projects)
/// {
/// Information(
/// @"Solution project file:
/// Name: {0}
/// Path: {1}
/// Id : {2}
/// Type: {3}",
/// project.Name,
/// project.Path,
/// project.Id,
/// project.Type
/// );
/// }
/// </code>
/// </example>
public Cake.Common.Solution.SolutionParserResult ParseSolution(Cake.Core.IO.FilePath solutionPath)
{
return Cake.Common.Solution.SolutionAliases.ParseSolution(Context, solutionPath);
}
/// <summary>
/// Parses project information from project file
/// </summary>
/// <param name="context">The context.</param>
/// <param name="projectPath">The project file path.</param>
/// <returns>A parsed project.</returns>
/// <example>
/// <code>
/// var parsedProject = ParseProject("./src/Cake/Cake.csproj");
/// Information(
/// @" Parsed project file:
/// Configuration : {0}
/// Platform : {1}
/// OutputType : {2}
/// OutputPath : {3}
/// RootNameSpace : {4}
/// AssemblyName : {5}
/// TargetFrameworkVersion: {6}
/// Files : {7}",
/// parsedProject.Configuration,
/// parsedProject.Platform,
/// parsedProject.OutputType,
/// parsedProject.OutputPath,
/// parsedProject.RootNameSpace,
/// parsedProject.AssemblyName,
/// parsedProject.TargetFrameworkVersion,
/// string.Concat(
/// parsedProject
/// .Files
/// .Select(
/// file=&gt; string.Format(
/// "\r\n {0}",
/// file.FilePath
/// )
/// )
/// )
/// );
/// </code>
/// </example>
public Cake.Common.Solution.Project.ProjectParserResult ParseProject(Cake.Core.IO.FilePath projectPath)
{
return Cake.Common.Solution.Project.ProjectAliases.ParseProject(Context, projectPath);
}
/// <summary>
/// Parses Xml documentation example code from given path.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="xmlFilePath">The Path to the file to parse.</param>
/// <returns>Parsed example code.</returns>
/// <example>
/// <code>
/// var exampleCodes = ParseXmlDocExampleCode("./Cake.Common.xml");
/// foreach(var exampleCode in exampleCodes)
/// {
/// Information(
/// "{0}\r\n{1}",
/// exampleCode.Name,
/// exampleCode.Code
/// );
/// }
/// </code>
/// </example>
public System.Collections.Generic.IEnumerable<Cake.Common.Solution.Project.XmlDoc.XmlDocExampleCode> ParseXmlDocExampleCode(Cake.Core.IO.FilePath xmlFilePath)
{
return Cake.Common.Solution.Project.XmlDoc.XmlDocAliases.ParseXmlDocExampleCode(Context, xmlFilePath);
}
/// <summary>
/// Parses Xml documentation example code from file(s) using given pattern.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The globber file pattern.</param>
/// <returns>Parsed example code.</returns>
/// <example>
/// <code>
/// var filesExampleCodes = ParseXmlDocFilesExampleCode("./Cake.*.xml");
/// foreach(var exampleCode in filesExampleCodes)
/// {
/// Information(
/// "{0}\r\n{1}",
/// exampleCode.Name,
/// exampleCode.Code
/// );
/// }
/// </code>
/// </example>
public System.Collections.Generic.IEnumerable<Cake.Common.Solution.Project.XmlDoc.XmlDocExampleCode> ParseXmlDocFilesExampleCode(System.String pattern)
{
return Cake.Common.Solution.Project.XmlDoc.XmlDocAliases.ParseXmlDocFilesExampleCode(Context, pattern);
}
/// <summary>
/// Creates an assembly information file.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="outputPath">The output path.</param>
/// <param name="settings">The settings.</param>
/// <example>
/// <code>
/// var file = "./SolutionInfo.cs";
/// var version = "0.0.1";
/// var buildNo = "123";
/// var semVersion = string.Concat(version + "-" + buildNo);
/// CreateAssemblyInfo(file, new AssemblyInfoSettings {
/// Product = "SampleProject",
/// Version = version,
/// FileVersion = version,
/// InformationalVersion = semVersion,
/// Copyright = string.Format("Copyright (c) Contoso 2014 - {0}", DateTime.Now.Year)
/// });
/// </code>
/// </example>
public void CreateAssemblyInfo(Cake.Core.IO.FilePath outputPath, Cake.Common.Solution.Project.Properties.AssemblyInfoSettings settings)
{
Cake.Common.Solution.Project.Properties.AssemblyInfoAliases.CreateAssemblyInfo(Context, outputPath, settings);
}
/// <summary>
/// Parses an existing assembly information file.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="assemblyInfoPath">The assembly info path.</param>
/// <returns>The content of the assembly info file.</returns>
/// <example>
/// <code>
/// var assemblyInfo = ParseAssemblyInfo("./SolutionInfo.cs");
/// Information("Version: {0}", assemblyInfo.AssemblyVersion);
/// Information("File version: {0}", assemblyInfo.AssemblyFileVersion);
/// Information("Informational version: {0}", assemblyInfo.AssemblyInformationalVersion);
/// </code>
/// </example>
public Cake.Common.Solution.Project.Properties.AssemblyInfoParseResult ParseAssemblyInfo(Cake.Core.IO.FilePath assemblyInfoPath)
{
return Cake.Common.Solution.Project.Properties.AssemblyInfoAliases.ParseAssemblyInfo(Context, assemblyInfoPath);
}
/// <summary>
/// Downloads the specified resource over HTTP to a temporary file.
/// </summary>
/// <example>
/// <code>
/// var resource = DownloadFile("http://www.example.org/index.html");
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="address">The URL of the resource to download.</param>
/// <returns>The path to the downloaded file.</returns>
public Cake.Core.IO.FilePath DownloadFile(System.String address)
{
return Cake.Common.Net.HttpAliases.DownloadFile(Context, address);
}
/// <summary>
/// Downloads the specified resource over HTTP to a temporary file with specified settings.
/// </summary>
/// <example>
/// <code>
/// var resource = DownloadFile("http://www.example.org/index.html", new DownloadFileSettings()
/// {
/// Username = "bob",
/// Password = "builder"
/// });
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="address">The URL of the resource to download.</param>
/// <param name="settings">The settings.</param>
/// <returns>The path to the downloaded file.</returns>
public Cake.Core.IO.FilePath DownloadFile(System.String address, Cake.Common.Net.DownloadFileSettings settings)
{
return Cake.Common.Net.HttpAliases.DownloadFile(Context, address, settings);
}
/// <summary>
/// Downloads the specified resource over HTTP to a temporary file.
/// </summary>
/// <example>
/// <code>
/// var address = new Uri("http://www.example.org/index.html");
/// var resource = DownloadFile(address);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="address">The URL of file to download.</param>
/// <returns>The path to the downloaded file.</returns>
public Cake.Core.IO.FilePath DownloadFile(System.Uri address)
{
return Cake.Common.Net.HttpAliases.DownloadFile(Context, address);
}
/// <summary>
/// Downloads the specified resource over HTTP to a temporary file with specified settings.
/// </summary>
/// <example>
/// <code>
/// var address = new Uri("http://www.example.org/index.html");
/// var resource = DownloadFile(address, new DownloadFileSettings()
/// {
/// Username = "bob",
/// Password = "builder"
/// });
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="address">The URL of file to download.</param>
/// <param name="settings">The settings.</param>
/// <returns>The path to the downloaded file.</returns>
public Cake.Core.IO.FilePath DownloadFile(System.Uri address, Cake.Common.Net.DownloadFileSettings settings)
{
return Cake.Common.Net.HttpAliases.DownloadFile(Context, address, settings);
}
/// <summary>
/// Downloads the specified resource over HTTP to the specified output path.
/// </summary>
/// <example>
/// <code>
/// var outputPath = File("./index.html");
/// DownloadFile("http://www.example.org/index.html", outputPath);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="address">The URL of the resource to download.</param>
/// <param name="outputPath">The output path.</param>
public void DownloadFile(System.String address, Cake.Core.IO.FilePath outputPath)
{
Cake.Common.Net.HttpAliases.DownloadFile(Context, address, outputPath);
}
/// <summary>
/// Downloads the specified resource over HTTP to the specified output path and settings.
/// </summary>
/// <example>
/// <code>
/// var outputPath = File("./index.html");
/// DownloadFile("http://www.example.org/index.html", outputPath, new DownloadFileSettings()
/// {
/// Username = "bob",
/// Password = "builder"
/// });
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="address">The URL of the resource to download.</param>
/// <param name="outputPath">The output path.</param>
/// <param name="settings">The settings.</param>
public void DownloadFile(System.String address, Cake.Core.IO.FilePath outputPath, Cake.Common.Net.DownloadFileSettings settings)
{
Cake.Common.Net.HttpAliases.DownloadFile(Context, address, outputPath, settings);
}
/// <summary>
/// Downloads the specified resource over HTTP to the specified output path.
/// </summary>
/// <example>
/// <code>
/// var address = new Uri("http://www.example.org/index.html");
/// var outputPath = File("./index.html");
/// DownloadFile(address, outputPath, new DownloadFileSettings()
/// {
/// Username = "bob",
/// Password = "builder"
/// });
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="address">The URL of the resource to download.</param>
/// <param name="outputPath">The output path.</param>
/// <param name="settings">The settings.</param>
public void DownloadFile(System.Uri address, Cake.Core.IO.FilePath outputPath, Cake.Common.Net.DownloadFileSettings settings)
{
Cake.Common.Net.HttpAliases.DownloadFile(Context, address, outputPath, settings);
}
/// <summary>
/// Uploads the specified file via a HTTP POST to the specified uri using multipart/form-data.
/// </summary>
/// <example>
/// <code>
/// var address = new Uri("http://www.example.org/upload");
/// UploadFile(address, @"path/to/file.txt");
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="address">The URL of the upload resource.</param>
/// <param name="filePath">The file to upload.</param>
public void UploadFile(System.Uri address, Cake.Core.IO.FilePath filePath)
{
Cake.Common.Net.HttpAliases.UploadFile(Context, address, filePath);
}
/// <summary>
/// Uploads the specified file via a HTTP POST to the specified uri using multipart/form-data.
/// </summary>
/// <example>
/// <code>
/// var address = "http://www.example.org/upload";
/// UploadFile(address, @"path/to/file.txt");
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="address">The URL of the upload resource.</param>
/// <param name="filePath">The file to upload.</param>
public void UploadFile(System.String address, Cake.Core.IO.FilePath filePath)
{
Cake.Common.Net.HttpAliases.UploadFile(Context, address, filePath);
}
/// <summary>
/// Uploads the specified byte array via a HTTP POST to the specified uri using multipart/form-data.
/// </summary>
/// <example>
/// <code>
/// var address = new Uri("http://www.example.org/upload");
/// UploadFile(address, @"path/to/file.txt");
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="address">The URL of the upload resource.</param>
/// <param name="data">The data to upload.</param>
/// <param name="fileName">The filename to give the uploaded data</param>
public void UploadFile(System.Uri address, System.Byte[] data, System.String fileName)
{
Cake.Common.Net.HttpAliases.UploadFile(Context, address, data, fileName);
}
/// <summary>
/// Uploads the specified byte array via a HTTP POST to the specified uri using multipart/form-data.
/// </summary>
/// <example>
/// <code>
/// var address = "http://www.example.org/upload";
/// UploadFile(address, @"path/to/file.txt");
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="address">The URL of the upload resource.</param>
/// <param name="data">The data to upload.</param>
/// <param name="fileName">The filename to give the uploaded data</param>
public void UploadFile(System.String address, System.Byte[] data, System.String fileName)
{
Cake.Common.Net.HttpAliases.UploadFile(Context, address, data, fileName);
}
/// <summary>
/// Gets a directory path from string.
/// </summary>
/// <example>
/// <code>
/// // Get the temp directory.
/// var root = Directory("./");
/// var temp = root + Directory("temp");
///
/// // Clean the directory.
/// CleanDirectory(temp);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="path">The path.</param>
/// <returns>A directory path.</returns>
public Cake.Common.IO.Paths.ConvertableDirectoryPath Directory(System.String path)
{
return Cake.Common.IO.DirectoryAliases.Directory(Context, path);
}
/// <summary>
/// Deletes the specified directories.
/// </summary>
/// <example>
/// <code>
/// var directoriesToDelete = new DirectoryPath[]{
/// Directory("be"),
/// Directory("gone")
/// };
/// DeleteDirectories(directoriesToDelete, recursive:true);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="directories">The directory paths.</param>
/// <param name="recursive">Will perform a recursive delete if set to <c>true</c>.</param>
public void DeleteDirectories(System.Collections.Generic.IEnumerable<Cake.Core.IO.DirectoryPath> directories, System.Boolean recursive = false)
{
Context.Log.Warning("Warning: The alias DeleteDirectories has been made obsolete. Use the overload that accepts DeleteDirectorySettings instead.");
#pragma warning disable 0618
Cake.Common.IO.DirectoryAliases.DeleteDirectories(Context, directories, recursive);
#pragma warning restore 0618
}
/// <summary>
/// Deletes the specified directories.
/// </summary>
/// <example>
/// <code>
/// var directoriesToDelete = new DirectoryPath[]{
/// Directory("be"),
/// Directory("gone")
/// };
/// DeleteDirectories(directoriesToDelete, new DeleteDirectorySettings {
/// Recursive = true,
/// Force = true
/// });
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="directories">The directory paths.</param>
/// <param name="settings">The delete settings.</param>
public void DeleteDirectories(System.Collections.Generic.IEnumerable<Cake.Core.IO.DirectoryPath> directories, Cake.Common.IO.DeleteDirectorySettings settings)
{
Cake.Common.IO.DirectoryAliases.DeleteDirectories(Context, directories, settings);
}
/// <summary>
/// Deletes the specified directories.
/// </summary>
/// <example>
/// <code>
/// var directoriesToDelete = new []{
/// "be",
/// "gone"
/// };
/// DeleteDirectories(directoriesToDelete, recursive:true);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="directories">The directory paths.</param>
/// <param name="recursive">Will perform a recursive delete if set to <c>true</c>.</param>
public void DeleteDirectories(System.Collections.Generic.IEnumerable<System.String> directories, System.Boolean recursive = false)
{
Context.Log.Warning("Warning: The alias DeleteDirectories has been made obsolete. Use the overload that accepts DeleteDirectorySettings instead.");
#pragma warning disable 0618
Cake.Common.IO.DirectoryAliases.DeleteDirectories(Context, directories, recursive);
#pragma warning restore 0618
}
/// <summary>
/// Deletes the specified directories.
/// </summary>
/// <example>
/// <code>
/// var directoriesToDelete = new []{
/// "be",
/// "gone"
/// };
/// DeleteDirectories(directoriesToDelete, new DeleteDirectorySettings {
/// Recursive = true,
/// Force = true
/// });
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="directories">The directory paths.</param>
/// <param name="settings">The delete settings.</param>
public void DeleteDirectories(System.Collections.Generic.IEnumerable<System.String> directories, Cake.Common.IO.DeleteDirectorySettings settings)
{
Cake.Common.IO.DirectoryAliases.DeleteDirectories(Context, directories, settings);
}
/// <summary>
/// Deletes the specified directory.
/// </summary>
/// <example>
/// <code>
/// DeleteDirectory("./be/gone", recursive:true);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="path">The directory path.</param>
/// <param name="recursive">Will perform a recursive delete if set to <c>true</c>.</param>
public void DeleteDirectory(Cake.Core.IO.DirectoryPath path, System.Boolean recursive = false)
{
Context.Log.Warning("Warning: The alias DeleteDirectory has been made obsolete. Use the overload that accepts DeleteDirectorySettings instead.");
#pragma warning disable 0618
Cake.Common.IO.DirectoryAliases.DeleteDirectory(Context, path, recursive);
#pragma warning restore 0618
}
/// <summary>
/// Deletes the specified directory.
/// </summary>
/// <example>
/// <code>
/// DeleteDirectory("./be/gone", new DeleteDirectorySettings {
/// Recursive = true,
/// Force = true
/// });
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="path">The directory path.</param>
/// <param name="settings">The delete settings.</param>
public void DeleteDirectory(Cake.Core.IO.DirectoryPath path, Cake.Common.IO.DeleteDirectorySettings settings)
{
Cake.Common.IO.DirectoryAliases.DeleteDirectory(Context, path, settings);
}
/// <summary>
/// Cleans the directories matching the specified pattern.
/// Cleaning the directory will remove all its content but not the directory itself.
/// </summary>
/// <example>
/// <code>
/// CleanDirectories("./src/**/bin/debug");
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern to match.</param>
public void CleanDirectories(System.String pattern)
{
Cake.Common.IO.DirectoryAliases.CleanDirectories(Context, pattern);
}
/// <summary>
/// Cleans the directories matching the specified pattern.
/// Cleaning the directory will remove all its content but not the directory itself.
/// </summary>
/// <example>
/// <code>
/// Func&lt;IFileSystemInfo, bool&gt; exclude_node_modules =
/// fileSystemInfo=&gt;!fileSystemInfo.Path.FullPath.EndsWith(
/// "node_modules",
/// StringComparison.OrdinalIgnoreCase);
/// CleanDirectories("./src/**/bin/debug", exclude_node_modules);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern to match.</param>
/// <param name="predicate">The predicate used to filter directories based on file system information.</param>
public void CleanDirectories(System.String pattern, System.Func<Cake.Core.IO.IFileSystemInfo, System.Boolean> predicate)
{
Cake.Common.IO.DirectoryAliases.CleanDirectories(Context, pattern, predicate);
}
/// <summary>
/// Cleans the specified directories.
/// Cleaning a directory will remove all its content but not the directory itself.
/// </summary>
/// <example>
/// <code>
/// var directoriesToClean = GetDirectories("./src/**/bin/");
/// CleanDirectories(directoriesToClean);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="directories">The directory paths.</param>
public void CleanDirectories(System.Collections.Generic.IEnumerable<Cake.Core.IO.DirectoryPath> directories)
{
Cake.Common.IO.DirectoryAliases.CleanDirectories(Context, directories);
}
/// <summary>
/// Cleans the specified directories.
/// Cleaning a directory will remove all its content but not the directory itself.
/// </summary>
/// <example>
/// <code>
/// var directoriesToClean = new []{
/// "./src/Cake/obj",
/// "./src/Cake.Common/obj"
/// };
/// CleanDirectories(directoriesToClean);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="directories">The directory paths.</param>
public void CleanDirectories(System.Collections.Generic.IEnumerable<System.String> directories)
{
Cake.Common.IO.DirectoryAliases.CleanDirectories(Context, directories);
}
/// <summary>
/// Cleans the specified directory.
/// </summary>
/// <example>
/// <code>
/// CleanDirectory("./src/Cake.Common/obj");
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="path">The directory path.</param>
public void CleanDirectory(Cake.Core.IO.DirectoryPath path)
{
Cake.Common.IO.DirectoryAliases.CleanDirectory(Context, path);
}
/// <summary>
/// Cleans the specified directory.
/// </summary>
/// <example>
/// <code>
/// CleanDirectory("./src/Cake.Common/obj", fileSystemInfo=&gt;!fileSystemInfo.Hidden);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="path">The directory path.</param>
/// <param name="predicate">Predicate used to determine which files/directories should get deleted.</param>
public void CleanDirectory(Cake.Core.IO.DirectoryPath path, System.Func<Cake.Core.IO.IFileSystemInfo, System.Boolean> predicate)
{
Cake.Common.IO.DirectoryAliases.CleanDirectory(Context, path, predicate);
}
/// <summary>
/// Creates the specified directory.
/// </summary>
/// <example>
/// <code>
/// CreateDirectory("publish");
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="path">The directory path.</param>
public void CreateDirectory(Cake.Core.IO.DirectoryPath path)
{
Cake.Common.IO.DirectoryAliases.CreateDirectory(Context, path);
}
/// <summary>
/// Creates the specified directory if it does not exist.
/// </summary>
/// <example>
/// <code>
/// EnsureDirectoryExists("publish");
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="path">The directory path.</param>
public void EnsureDirectoryExists(Cake.Core.IO.DirectoryPath path)
{
Cake.Common.IO.DirectoryAliases.EnsureDirectoryExists(Context, path);
}
/// <summary>
/// Copies the contents of a directory, including subdirectories to the specified location.
/// </summary>
/// <example>
/// <code>
/// CopyDirectory("source_path", "destination_path");
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="source">The source directory path.</param>
/// <param name="destination">The destination directory path.</param>
public void CopyDirectory(Cake.Core.IO.DirectoryPath source, Cake.Core.IO.DirectoryPath destination)
{
Cake.Common.IO.DirectoryAliases.CopyDirectory(Context, source, destination);
}
/// <summary>
/// Determines whether the given path refers to an existing directory.
/// </summary>
/// <example>
/// <code>
/// var dir = "publish";
/// if (!DirectoryExists(dir))
/// {
/// CreateDirectory(dir);
/// }
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="path">The <see cref="T:Cake.Core.IO.DirectoryPath" /> to check.</param>
/// <returns>
/// <c>true</c> if <paramref name="path" /> refers to an existing directory;
/// <c>false</c> if the directory does not exist or an error occurs when trying to
/// determine if the specified path exists.</returns>
public System.Boolean DirectoryExists(Cake.Core.IO.DirectoryPath path)
{
return Cake.Common.IO.DirectoryAliases.DirectoryExists(Context, path);
}
/// <summary>
/// Makes the path absolute (if relative) using the current working directory.
/// </summary>
/// <example>
/// <code>
/// var path = MakeAbsolute(Directory("./resources"));
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="path">The path.</param>
/// <returns>An absolute directory path.</returns>
public Cake.Core.IO.DirectoryPath MakeAbsolute(Cake.Core.IO.DirectoryPath path)
{
return Cake.Common.IO.DirectoryAliases.MakeAbsolute(Context, path);
}
/// <summary>
/// Moves an existing directory to a new location, providing the option to specify a new directory name.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="directoryPath">The directory path.</param>
/// <param name="targetDirectoryPath">The target directory path.</param>
/// <example>
/// <code>
/// MoveDirectory("mydir", "newparent/newdir");
/// </code>
/// </example>
public void MoveDirectory(Cake.Core.IO.DirectoryPath directoryPath, Cake.Core.IO.DirectoryPath targetDirectoryPath)
{
Cake.Common.IO.DirectoryAliases.MoveDirectory(Context, directoryPath, targetDirectoryPath);
}
/// <summary>
/// Gets a list of all the directories inside a directory.
/// </summary>
/// <example>
/// <code>
/// var directories = GetSubDirectories("some/dir");
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="directoryPath">The directory path.</param>
/// <returns>An absolute directory path.</returns>
public Cake.Core.IO.DirectoryPathCollection GetSubDirectories(Cake.Core.IO.DirectoryPath directoryPath)
{
return Cake.Common.IO.DirectoryAliases.GetSubDirectories(Context, directoryPath);
}
/// <summary>
/// Gets a file path from string.
/// </summary>
/// <example>
/// <code>
/// // Get the temp file.
/// var root = Directory("./");
/// var temp = root + File("temp");
///
/// // Delete the file.
/// CleanDirectory(temp);
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="path">The path.</param>
/// <returns>A file path.</returns>
public Cake.Common.IO.Paths.ConvertableFilePath File(System.String path)
{
return Cake.Common.IO.FileAliases.File(Context, path);
}
/// <summary>
/// Copies an existing file to a new location.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The file path.</param>
/// <param name="targetDirectoryPath">The target directory path.</param>
/// <example>
/// <code>
/// CopyFileToDirectory("test.txt", "./targetdir");
/// </code>
/// </example>
public void CopyFileToDirectory(Cake.Core.IO.FilePath filePath, Cake.Core.IO.DirectoryPath targetDirectoryPath)
{
Cake.Common.IO.FileAliases.CopyFileToDirectory(Context, filePath, targetDirectoryPath);
}
/// <summary>
/// Copies an existing file to a new file, providing the option to specify a new file name.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The file path.</param>
/// <param name="targetFilePath">The target file path.</param>
/// <example>
/// <code>
/// CopyFile("test.tmp", "test.txt");
/// </code>
/// </example>
public void CopyFile(Cake.Core.IO.FilePath filePath, Cake.Core.IO.FilePath targetFilePath)
{
Cake.Common.IO.FileAliases.CopyFile(Context, filePath, targetFilePath);
}
/// <summary>
/// Copies all files matching the provided pattern to a new location.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="targetDirectoryPath">The target directory path.</param>
/// <example>
/// <code>
/// CopyFiles("Cake.*", "./publish");
/// </code>
/// </example>
public void CopyFiles(System.String pattern, Cake.Core.IO.DirectoryPath targetDirectoryPath)
{
Cake.Common.IO.FileAliases.CopyFiles(Context, pattern, targetDirectoryPath);
}
/// <summary>
/// Copies existing files to a new location.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="filePaths">The file paths.</param>
/// <param name="targetDirectoryPath">The target directory path.</param>
/// <example>
/// <code>
/// var files = GetFiles("./**/Cake.*");
/// CopyFiles(files, "destination");
/// </code>
/// </example>
public void CopyFiles(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> filePaths, Cake.Core.IO.DirectoryPath targetDirectoryPath)
{
Cake.Common.IO.FileAliases.CopyFiles(Context, filePaths, targetDirectoryPath);
}
/// <summary>
/// Copies existing files to a new location.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="filePaths">The file paths.</param>
/// <param name="targetDirectoryPath">The target directory path.</param>
/// <example>
/// <code>
/// CreateDirectory("destination");
/// var files = new [] {
/// "Cake.exe",
/// "Cake.pdb"
/// };
/// CopyFiles(files, "destination");
/// </code>
/// </example>
public void CopyFiles(System.Collections.Generic.IEnumerable<System.String> filePaths, Cake.Core.IO.DirectoryPath targetDirectoryPath)
{
Cake.Common.IO.FileAliases.CopyFiles(Context, filePaths, targetDirectoryPath);
}
/// <summary>
/// Copies all files matching the provided pattern to a new location.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="targetDirectoryPath">The target directory path.</param>
/// <param name="preserveFolderStructure">Keep the folder structure.</param>
/// <example>
/// <code>
/// CopyFiles("Cake.*", "./publish");
/// </code>
/// </example>
public void CopyFiles(System.String pattern, Cake.Core.IO.DirectoryPath targetDirectoryPath, System.Boolean preserveFolderStructure)
{
Cake.Common.IO.FileAliases.CopyFiles(Context, pattern, targetDirectoryPath, preserveFolderStructure);
}
/// <summary>
/// Copies existing files to a new location.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="filePaths">The file paths.</param>
/// <param name="targetDirectoryPath">The target directory path.</param>
/// <param name="preserveFolderStructure">Keep the folder structure.</param>
/// <example>
/// <code>
/// var files = GetFiles("./**/Cake.*");
/// CopyFiles(files, "destination");
/// </code>
/// </example>
public void CopyFiles(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> filePaths, Cake.Core.IO.DirectoryPath targetDirectoryPath, System.Boolean preserveFolderStructure)
{
Cake.Common.IO.FileAliases.CopyFiles(Context, filePaths, targetDirectoryPath, preserveFolderStructure);
}
/// <summary>
/// Copies existing files to a new location.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="filePaths">The file paths.</param>
/// <param name="targetDirectoryPath">The target directory path.</param>
/// <param name="preserveFolderStructure">Keep the folder structure.</param>
/// <example>
/// <code>
/// CreateDirectory("destination");
/// var files = new [] {
/// "Cake.exe",
/// "Cake.pdb"
/// };
/// CopyFiles(files, "destination");
/// </code>
/// </example>
public void CopyFiles(System.Collections.Generic.IEnumerable<System.String> filePaths, Cake.Core.IO.DirectoryPath targetDirectoryPath, System.Boolean preserveFolderStructure)
{
Cake.Common.IO.FileAliases.CopyFiles(Context, filePaths, targetDirectoryPath, preserveFolderStructure);
}
/// <summary>
/// Moves an existing file to a new location.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The file path.</param>
/// <param name="targetDirectoryPath">The target directory path.</param>
/// <example>
/// <code>
/// MoveFileToDirectory("test.txt", "./targetdir");
/// </code>
/// </example>
public void MoveFileToDirectory(Cake.Core.IO.FilePath filePath, Cake.Core.IO.DirectoryPath targetDirectoryPath)
{
Cake.Common.IO.FileAliases.MoveFileToDirectory(Context, filePath, targetDirectoryPath);
}
/// <summary>
/// Moves existing files matching the specified pattern to a new location.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="targetDirectoryPath">The target directory path.</param>
/// <example>
/// <code>
/// MoveFiles("./publish/Cake.*", "./destination");
/// </code>
/// </example>
public void MoveFiles(System.String pattern, Cake.Core.IO.DirectoryPath targetDirectoryPath)
{
Cake.Common.IO.FileAliases.MoveFiles(Context, pattern, targetDirectoryPath);
}
/// <summary>
/// Moves existing files to a new location.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="filePaths">The file paths.</param>
/// <param name="targetDirectoryPath">The target directory path.</param>
/// <example>
/// <code>
/// var files = GetFiles("./publish/Cake.*");
/// MoveFiles(files, "destination");
/// </code>
/// </example>
public void MoveFiles(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> filePaths, Cake.Core.IO.DirectoryPath targetDirectoryPath)
{
Cake.Common.IO.FileAliases.MoveFiles(Context, filePaths, targetDirectoryPath);
}
/// <summary>
/// Moves an existing file to a new location, providing the option to specify a new file name.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The file path.</param>
/// <param name="targetFilePath">The target file path.</param>
/// <example>
/// <code>
/// MoveFile("test.tmp", "test.txt");
/// </code>
/// </example>
public void MoveFile(Cake.Core.IO.FilePath filePath, Cake.Core.IO.FilePath targetFilePath)
{
Cake.Common.IO.FileAliases.MoveFile(Context, filePath, targetFilePath);
}
/// <summary>
/// Deletes the specified files.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <example>
/// <code>
/// DeleteFiles("./publish/Cake.*");
/// </code>
/// </example>
public void DeleteFiles(System.String pattern)
{
Cake.Common.IO.FileAliases.DeleteFiles(Context, pattern);
}
/// <summary>
/// Deletes the specified files.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="filePaths">The file paths.</param>
/// <example>
/// <code>
/// var files = GetFiles("./destination/Cake.*");
/// DeleteFiles(files);
/// </code>
/// </example>
public void DeleteFiles(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> filePaths)
{
Cake.Common.IO.FileAliases.DeleteFiles(Context, filePaths);
}
/// <summary>
/// Deletes the specified file.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The file path.</param>
/// <example>
/// <code>
/// DeleteFile("deleteme.txt");
/// </code>
/// </example>
public void DeleteFile(Cake.Core.IO.FilePath filePath)
{
Cake.Common.IO.FileAliases.DeleteFile(Context, filePath);
}
/// <summary>
/// Determines whether the given path refers to an existing file.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The <see cref="T:Cake.Core.IO.FilePath" /> to check.</param>
/// <returns>
/// <c>true</c> if <paramref name="filePath" /> refers to an existing file;
/// <c>false</c> if the file does not exist or an error occurs when trying to
/// determine if the specified file exists.</returns>
/// <example>
/// <code>
/// if (FileExists("findme.txt"))
/// {
/// Information("File exists!");
/// }
/// </code>
/// </example>
public System.Boolean FileExists(Cake.Core.IO.FilePath filePath)
{
return Cake.Common.IO.FileAliases.FileExists(Context, filePath);
}
/// <summary>
/// Makes the path absolute (if relative) using the current working directory.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="path">The path.</param>
/// <returns>An absolute file path.</returns>
/// <example>
/// <code>
/// var path = MakeAbsolute(File("./resources"));
/// </code>
/// </example>
public Cake.Core.IO.FilePath MakeAbsolute(Cake.Core.IO.FilePath path)
{
return Cake.Common.IO.FileAliases.MakeAbsolute(Context, path);
}
/// <summary>
/// Gets the size of a file in bytes.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The path.</param>
/// <returns>Size of file in bytes or -1 if file doesn't exist.</returns>
/// <example>
/// <code>
/// Information("File size: {0}", FileSize("./build.cake"));
/// </code>
/// </example>
public System.Int64 FileSize(Cake.Core.IO.FilePath filePath)
{
return Cake.Common.IO.FileAliases.FileSize(Context, filePath);
}
/// <summary>
/// Gets all files matching the specified pattern.
/// </summary>
/// <example>
/// <code>
/// var files = GetFiles("./**/Cake.*.dll");
/// foreach(var file in files)
/// {
/// Information("File: {0}", file);
/// }
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The glob pattern to match.</param>
/// <returns>A <see cref="T:Cake.Core.IO.FilePathCollection" />.</returns>
public Cake.Core.IO.FilePathCollection GetFiles(System.String pattern)
{
return Cake.Common.IO.GlobbingAliases.GetFiles(Context, pattern);
}
/// <summary>
/// Gets all files matching the specified pattern.
/// </summary>
/// <example>
/// <code>
/// Func&lt;IFileSystemInfo, bool&gt; exclude_node_modules =
/// fileSystemInfo =&gt; !fileSystemInfo.Path.FullPath.EndsWith(
/// "node_modules", StringComparison.OrdinalIgnoreCase);
///
/// var files = GetFiles("./**/Cake.*.dll", exclude_node_modules);
/// foreach(var file in files)
/// {
/// Information("File: {0}", file);
/// }
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The glob pattern to match.</param>
/// <param name="predicate">The predicate used to filter directories based on file system information.</param>
/// <returns>A <see cref="T:Cake.Core.IO.FilePathCollection" />.</returns>
public Cake.Core.IO.FilePathCollection GetFiles(System.String pattern, System.Func<Cake.Core.IO.IDirectory, System.Boolean> predicate)
{
return Cake.Common.IO.GlobbingAliases.GetFiles(Context, pattern, predicate);
}
/// <summary>
/// Gets all directory matching the specified pattern.
/// </summary>
/// <example>
/// <code>
/// var directories = GetDirectories("./src/**/obj/*");
/// foreach(var directory in directories)
/// {
/// Information("Directory: {0}", directory);
/// }
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The glob pattern to match.</param>
/// <returns>A <see cref="T:Cake.Core.IO.DirectoryPathCollection" />.</returns>
public Cake.Core.IO.DirectoryPathCollection GetDirectories(System.String pattern)
{
return Cake.Common.IO.GlobbingAliases.GetDirectories(Context, pattern);
}
/// <summary>
/// Gets all directory matching the specified pattern.
/// </summary>
/// <example>
/// <code>
/// Func&lt;IFileSystemInfo, bool&gt; exclude_node_modules =
/// fileSystemInfo =&gt; !fileSystemInfo.Path.FullPath.EndsWith(
/// "node_modules", StringComparison.OrdinalIgnoreCase);
///
/// var directories = GetDirectories("./src/**/obj/*", exclude_node_modules);
/// foreach(var directory in directories)
/// {
/// Information("Directory: {0}", directory);
/// }
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The glob pattern to match.</param>
/// <param name="predicate">The predicate used to filter directories based on file system information.</param>
/// <returns>A <see cref="T:Cake.Core.IO.DirectoryPathCollection" />.</returns>
public Cake.Core.IO.DirectoryPathCollection GetDirectories(System.String pattern, System.Func<Cake.Core.IO.IDirectory, System.Boolean> predicate)
{
return Cake.Common.IO.GlobbingAliases.GetDirectories(Context, pattern, predicate);
}
/// <summary>
/// Zips the specified directory.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="rootPath">The root path.</param>
/// <param name="outputPath">The output path.</param>
/// <example>
/// <code>
/// Zip("./publish", "publish.zip");
/// </code>
/// </example>
public void Zip(Cake.Core.IO.DirectoryPath rootPath, Cake.Core.IO.FilePath outputPath)
{
Cake.Common.IO.ZipAliases.Zip(Context, rootPath, outputPath);
}
/// <summary>
/// Zips the files matching the specified pattern.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="rootPath">The root path.</param>
/// <param name="outputPath">The output path.</param>
/// <param name="pattern">The pattern.</param>
/// <example>
/// <code>
/// Zip("./", "xmlfiles.zip", "./*.xml");
/// </code>
/// </example>
public void Zip(Cake.Core.IO.DirectoryPath rootPath, Cake.Core.IO.FilePath outputPath, System.String pattern)
{
Cake.Common.IO.ZipAliases.Zip(Context, rootPath, outputPath, pattern);
}
/// <summary>
/// Zips the specified files.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="rootPath">The root path.</param>
/// <param name="outputPath">The output path.</param>
/// <param name="filePaths">The file paths.</param>
/// <example>
/// <code>
/// var files = GetFiles("./**/Cake.*.dll");
/// Zip("./", "cakeassemblies.zip", files);
/// </code>
/// </example>
public void Zip(Cake.Core.IO.DirectoryPath rootPath, Cake.Core.IO.FilePath outputPath, System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> filePaths)
{
Cake.Common.IO.ZipAliases.Zip(Context, rootPath, outputPath, filePaths);
}
/// <summary>
/// Zips the specified files.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="rootPath">The root path.</param>
/// <param name="outputPath">The output path.</param>
/// <param name="filePaths">The file paths.</param>
/// <example>
/// <code>
/// var files = new [] {
/// "./src/Cake/bin/Debug/Autofac.dll",
/// "./src/Cake/bin/Debug/Cake.Common.dll",
/// "./src/Cake/bin/Debug/Cake.Core.dll",
/// "./src/Cake/bin/Debug/Cake.exe"
/// };
/// Zip("./", "cakebinaries.zip", files);
/// </code>
/// </example>
public void Zip(Cake.Core.IO.DirectoryPath rootPath, Cake.Core.IO.FilePath outputPath, System.Collections.Generic.IEnumerable<System.String> filePaths)
{
Cake.Common.IO.ZipAliases.Zip(Context, rootPath, outputPath, filePaths);
}
/// <summary>
/// Unzips the specified file
/// </summary>
/// <param name="context">The context.</param>
/// <param name="zipFile">Zip file to unzip.</param>
/// <param name="outputPath">Output path to unzip into.</param>
/// <example>
/// <code>
/// Unzip("Cake.zip", "./cake");
/// </code>
/// </example>
public void Unzip(Cake.Core.IO.FilePath zipFile, Cake.Core.IO.DirectoryPath outputPath)
{
Cake.Common.IO.ZipAliases.Unzip(Context, zipFile, outputPath);
}
/// <summary>
/// Writes an error message to the log using the specified format information.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="format">The format.</param>
/// <param name="args">The arguments.</param>
/// <example>
/// <code>
/// Error("Hello {0}! Today is an {1:dddd}", "World", DateTime.Now);
/// </code>
/// </example>
public void Error(System.String format, params System.Object[] args)
{
Cake.Common.Diagnostics.LoggingAliases.Error(Context, format, args);
}
/// <summary>
/// Writes an error message to the log using the specified log message action.
/// Evaluation message only if verbosity same or more verbose.
/// </summary>
/// <param name="context">the context.</param>
/// <param name="logAction">The function called for message when logging.</param>
/// <example>
/// <code>
/// Error(logAction=&gt;logAction("Hello {0}! Today is an {1:dddd}", "World", DateTime.Now));
/// </code>
/// </example>
public void Error(Cake.Core.Diagnostics.LogAction logAction)
{
Cake.Common.Diagnostics.LoggingAliases.Error(Context, logAction);
}
/// <summary>
/// Writes an error message to the log using the specified value.
/// </summary>
/// <param name="context">the context.</param>
/// <param name="value">The value.</param>
/// <example>
/// <code>
/// Error(new {FirstName = "John", LastName="Doe"});
/// </code>
/// </example>
public void Error(System.Object value)
{
Cake.Common.Diagnostics.LoggingAliases.Error(Context, value);
}
/// <summary>
/// Writes an error message to the log using the specified string value.
/// </summary>
/// <param name="context">the context.</param>
/// <param name="value">The value.</param>
/// <example>
/// <code>
/// Error("{string}");
/// </code>
/// </example>
public void Error(System.String value)
{
Cake.Common.Diagnostics.LoggingAliases.Error(Context, value);
}
/// <summary>
/// Writes a warning message to the log using the specified format information.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="format">The format.</param>
/// <param name="args">The arguments.</param>
/// <example>
/// <code>
/// Warning("Hello {0}! Today is an {1:dddd}", "World", DateTime.Now);
/// </code>
/// </example>
public void Warning(System.String format, params System.Object[] args)
{
Cake.Common.Diagnostics.LoggingAliases.Warning(Context, format, args);
}
/// <summary>
/// Writes a warning message to the log using the specified log message action.
/// Evaluation message only if verbosity same or more verbose.
/// </summary>
/// <param name="context">the context.</param>
/// <param name="logAction">The function called for message when logging.</param>
/// <example>
/// <code>
/// Warning(logAction=&gt;logAction("Hello {0}! Today is an {1:dddd}", "World", DateTime.Now));
/// </code>
/// </example>
public void Warning(Cake.Core.Diagnostics.LogAction logAction)
{
Cake.Common.Diagnostics.LoggingAliases.Warning(Context, logAction);
}
/// <summary>
/// Writes an warning message to the log using the specified value.
/// </summary>
/// <param name="context">the context.</param>
/// <param name="value">The value.</param>
/// <example>
/// <code>
/// Warning(new {FirstName = "John", LastName="Doe"});
/// </code>
/// </example>
public void Warning(System.Object value)
{
Cake.Common.Diagnostics.LoggingAliases.Warning(Context, value);
}
/// <summary>
/// Writes an warning message to the log using the specified string value.
/// </summary>
/// <param name="context">the context.</param>
/// <param name="value">The value.</param>
/// <example>
/// <code>
/// Warning("{string}");
/// </code>
/// </example>
public void Warning(System.String value)
{
Cake.Common.Diagnostics.LoggingAliases.Warning(Context, value);
}
/// <summary>
/// Writes an informational message to the log using the specified format information.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="format">The format.</param>
/// <param name="args">The arguments.</param>
/// <example>
/// <code>
/// Information("Hello {0}! Today is an {1:dddd}", "World", DateTime.Now);
/// </code>
/// </example>
public void Information(System.String format, params System.Object[] args)
{
Cake.Common.Diagnostics.LoggingAliases.Information(Context, format, args);
}
/// <summary>
/// Writes an informational message to the log using the specified log message action.
/// Evaluation message only if verbosity same or more verbose.
/// </summary>
/// <param name="context">the context.</param>
/// <param name="logAction">The function called for message when logging.</param>
/// <example>
/// <code>
/// Information(logAction=&gt;logAction("Hello {0}! Today is an {1:dddd}", "World", DateTime.Now));
/// </code>
/// </example>
public void Information(Cake.Core.Diagnostics.LogAction logAction)
{
Cake.Common.Diagnostics.LoggingAliases.Information(Context, logAction);
}
/// <summary>
/// Writes an informational message to the log using the specified value.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="value">The value.</param>
/// <example>
/// <code>
/// Information(new {FirstName = "John", LastName="Doe"});
/// </code>
/// </example>
public void Information(System.Object value)
{
Cake.Common.Diagnostics.LoggingAliases.Information(Context, value);
}
/// <summary>
/// Writes an informational message to the log using the specified string value.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="value">The value.</param>
/// <example>
/// <code>
/// Information("{string}");
/// </code>
/// </example>
public void Information(System.String value)
{
Cake.Common.Diagnostics.LoggingAliases.Information(Context, value);
}
/// <summary>
/// Writes a verbose message to the log using the specified format information.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="format">The format.</param>
/// <param name="args">The arguments.</param>
/// <example>
/// <code>
/// Verbose("Hello {0}! Today is an {1:dddd}", "World", DateTime.Now);
/// </code>
/// </example>
public void Verbose(System.String format, params System.Object[] args)
{
Cake.Common.Diagnostics.LoggingAliases.Verbose(Context, format, args);
}
/// <summary>
/// Writes a verbose message to the log using the specified log message action.
/// Evaluation message only if verbosity same or more verbose.
/// </summary>
/// <param name="context">the context.</param>
/// <param name="logAction">The function called for message when logging.</param>
/// <example>
/// <code>
/// Verbose(logAction=&gt;logAction("Hello {0}! Today is an {1:dddd}", "World", DateTime.Now));
/// </code>
/// </example>
public void Verbose(Cake.Core.Diagnostics.LogAction logAction)
{
Cake.Common.Diagnostics.LoggingAliases.Verbose(Context, logAction);
}
/// <summary>
/// Writes a verbose message to the log using the specified value.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="value">The value.</param>
/// <example>
/// <code>
/// Verbose(new {FirstName = "John", LastName="Doe"});
/// </code>
/// </example>
public void Verbose(System.Object value)
{
Cake.Common.Diagnostics.LoggingAliases.Verbose(Context, value);
}
/// <summary>
/// Writes a verbose message to the log using the specified string value.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="value">The value.</param>
/// <example>
/// <code>
/// Verbose("{string}");
/// </code>
/// </example>
public void Verbose(System.String value)
{
Cake.Common.Diagnostics.LoggingAliases.Verbose(Context, value);
}
/// <summary>
/// Writes a debug message to the log using the specified format information.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="format">The format.</param>
/// <param name="args">The arguments.</param>
/// <example>
/// <code>
/// Debug("Hello {0}! Today is an {1:dddd}", "World", DateTime.Now);
/// </code>
/// </example>
public void Debug(System.String format, params System.Object[] args)
{
Cake.Common.Diagnostics.LoggingAliases.Debug(Context, format, args);
}
/// <summary>
/// Writes a debug message to the log using the specified log message action.
/// Evaluation message only if verbosity same or more verbose.
/// </summary>
/// <param name="context">the context.</param>
/// <param name="logAction">The function called for message when logging.</param>
/// <example>
/// <code>
/// Debug(logAction=&gt;logAction("Hello {0}! Today is an {1:dddd}", "World", DateTime.Now));
/// </code>
/// </example>
public void Debug(Cake.Core.Diagnostics.LogAction logAction)
{
Cake.Common.Diagnostics.LoggingAliases.Debug(Context, logAction);
}
/// <summary>
/// Writes a debug message to the log using the specified value.
/// </summary>
/// <param name="context">the context.</param>
/// <param name="value">The value.</param>
/// <example>
/// <code>
/// Debug(new {FirstName = "John", LastName="Doe"});
/// </code>
/// </example>
public void Debug(System.Object value)
{
Cake.Common.Diagnostics.LoggingAliases.Debug(Context, value);
}
/// <summary>
/// Writes a debug message to the log using the specified string value.
/// </summary>
/// <param name="context">the context.</param>
/// <param name="value">The value.</param>
/// <example>
/// <code>
/// Debug("{string}");
/// </code>
/// </example>
public void Debug(System.String value)
{
Cake.Common.Diagnostics.LoggingAliases.Debug(Context, value);
}
/// <summary>
/// Gets a <see cref="T:Cake.Common.Build.BuildSystem" /> instance that can
/// be used to query for information about the current build system.
/// </summary>
/// <example>
/// <code>
/// var isLocal = BuildSystem.IsLocalBuild;
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="T:Cake.Common.Build.BuildSystem" /> instance.</returns>
private Cake.Common.Build.BuildSystem _BuildSystem;
public Cake.Common.Build.BuildSystem BuildSystem
{
get
{
if (_BuildSystem==null)
{
_BuildSystem = Cake.Common.Build.BuildSystemAliases.BuildSystem(Context);
}
return _BuildSystem;
}
}
/// <summary>
/// Gets a <see cref="T:Cake.Common.Build.AppVeyor.AppVeyorProvider" /> instance that can
/// be used to manipulate the AppVeyor environment.
/// </summary>
/// <example>
/// <code>
/// var isAppVeyorBuild = AppVeyor.IsRunningOnAppVeyor;
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="N:Cake.Common.Build.AppVeyor" /> instance.</returns>
private Cake.Common.Build.AppVeyor.IAppVeyorProvider _AppVeyor;
public Cake.Common.Build.AppVeyor.IAppVeyorProvider AppVeyor
{
get
{
if (_AppVeyor==null)
{
_AppVeyor = Cake.Common.Build.BuildSystemAliases.AppVeyor(Context);
}
return _AppVeyor;
}
}
/// <summary>
/// Gets a <see cref="T:Cake.Common.Build.TeamCity.TeamCityProvider" /> instance that can
/// be used to manipulate the TeamCity environment.
/// </summary>
/// <example>
/// <code>
/// var isTeamCityBuild = TeamCity.IsRunningOnTeamCity;
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="N:Cake.Common.Build.TeamCity" /> instance.</returns>
private Cake.Common.Build.TeamCity.ITeamCityProvider _TeamCity;
public Cake.Common.Build.TeamCity.ITeamCityProvider TeamCity
{
get
{
if (_TeamCity==null)
{
_TeamCity = Cake.Common.Build.BuildSystemAliases.TeamCity(Context);
}
return _TeamCity;
}
}
/// <summary>
/// Gets a <see cref="T:Cake.Common.Build.MyGet.MyGetProvider" /> instance that can
/// be used to manipulate the MyGet environment.
/// </summary>
/// <example>
/// <code>
/// var isMyGetBuild = MyGet.IsRunningOnMyGet;
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="N:Cake.Common.Build.MyGet" /> instance.</returns>
private Cake.Common.Build.MyGet.IMyGetProvider _MyGet;
public Cake.Common.Build.MyGet.IMyGetProvider MyGet
{
get
{
if (_MyGet==null)
{
_MyGet = Cake.Common.Build.BuildSystemAliases.MyGet(Context);
}
return _MyGet;
}
}
/// <summary>
/// Gets a <see cref="T:Cake.Common.Build.Bamboo.BambooProvider" /> instance that can
/// be used to manipulate the Bamboo environment.
/// </summary>
/// <example>
/// <code>
/// var isBambooBuild = Bamboo.IsRunningOnBamboo;
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="N:Cake.Common.Build.Bamboo" /> instance.</returns>
private Cake.Common.Build.Bamboo.IBambooProvider _Bamboo;
public Cake.Common.Build.Bamboo.IBambooProvider Bamboo
{
get
{
if (_Bamboo==null)
{
_Bamboo = Cake.Common.Build.BuildSystemAliases.Bamboo(Context);
}
return _Bamboo;
}
}
/// <summary>
/// Gets a <see cref="T:Cake.Common.Build.ContinuaCI.ContinuaCIProvider" /> instance that can
/// be used to manipulate the Continua CI environment.
/// </summary>
/// <example>
/// <code>
/// var isContinuaCIBuild = ContinuaCI.IsRunningContinuaCI;
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="N:Cake.Common.Build.ContinuaCI" /> instance.</returns>
private Cake.Common.Build.ContinuaCI.IContinuaCIProvider _ContinuaCI;
public Cake.Common.Build.ContinuaCI.IContinuaCIProvider ContinuaCI
{
get
{
if (_ContinuaCI==null)
{
_ContinuaCI = Cake.Common.Build.BuildSystemAliases.ContinuaCI(Context);
}
return _ContinuaCI;
}
}
/// <summary>
/// Gets a <see cref="T:Cake.Common.Build.Jenkins.JenkinsProvider" /> instance that can be used to
/// obtain information from the Jenkins environment.
/// </summary>
/// <example>
/// <code>
/// var isJenkinsBuild = Jenkins.IsRunningOnJenkins;
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="N:Cake.Common.Build.Jenkins" /> instance.</returns>
private Cake.Common.Build.Jenkins.IJenkinsProvider _Jenkins;
public Cake.Common.Build.Jenkins.IJenkinsProvider Jenkins
{
get
{
if (_Jenkins==null)
{
_Jenkins = Cake.Common.Build.BuildSystemAliases.Jenkins(Context);
}
return _Jenkins;
}
}
/// <summary>
/// Gets a <see cref="T:Cake.Common.Build.Bitrise.BitriseProvider" /> instance that can be used to
/// obtain information from the Bitrise environment.
/// </summary>
/// <example>
/// <code>
/// var isBitriseBuild = Bitrise.IsRunningOnBitrise;
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="N:Cake.Common.Build.Bitrise" /> instance.</returns>
private Cake.Common.Build.Bitrise.IBitriseProvider _Bitrise;
public Cake.Common.Build.Bitrise.IBitriseProvider Bitrise
{
get
{
if (_Bitrise==null)
{
_Bitrise = Cake.Common.Build.BuildSystemAliases.Bitrise(Context);
}
return _Bitrise;
}
}
/// <summary>
/// Gets a <see cref="T:Cake.Common.Build.TravisCI.TravisCIProvider" /> instance that can be used to
/// obtain information from the Travis CI environment.
/// </summary>
/// <example>
/// <code>
/// var isTravisCIBuild = TravisCI.IsRunningOnTravisCI;
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="N:Cake.Common.Build.TravisCI" /> instance.</returns>
private Cake.Common.Build.TravisCI.ITravisCIProvider _TravisCI;
public Cake.Common.Build.TravisCI.ITravisCIProvider TravisCI
{
get
{
if (_TravisCI==null)
{
_TravisCI = Cake.Common.Build.BuildSystemAliases.TravisCI(Context);
}
return _TravisCI;
}
}
/// <summary>
/// Gets a <see cref="T:Cake.Common.Build.BitbucketPipelines.BitbucketPipelinesProvider" /> instance that can be used to
/// obtain information from the Bitbucket Pipelines environment.
/// </summary>
/// <example>
/// <code>
/// var isBitbucketPipelinesBuild = BitbucketPipelines.IsRunningOnBitbucketPipelines;
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="N:Cake.Common.Build.BitbucketPipelines" /> instance.</returns>
private Cake.Common.Build.BitbucketPipelines.IBitbucketPipelinesProvider _BitbucketPipelines;
public Cake.Common.Build.BitbucketPipelines.IBitbucketPipelinesProvider BitbucketPipelines
{
get
{
if (_BitbucketPipelines==null)
{
_BitbucketPipelines = Cake.Common.Build.BuildSystemAliases.BitbucketPipelines(Context);
}
return _BitbucketPipelines;
}
}
/// <summary>
/// Gets a <see cref="T:Cake.Common.Build.GoCD.GoCDProvider" /> instance that can be used to
/// obtain information from the Go.CD environment.
/// </summary>
/// <example>
/// <code>
/// var isGoCDBuild = GoCD.IsRunningOnGoCD;
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="N:Cake.Common.Build.GoCD" /> instance.</returns>
private Cake.Common.Build.GoCD.IGoCDProvider _GoCD;
public Cake.Common.Build.GoCD.IGoCDProvider GoCD
{
get
{
if (_GoCD==null)
{
_GoCD = Cake.Common.Build.BuildSystemAliases.GoCD(Context);
}
return _GoCD;
}
}
/// <summary>
/// Gets a <see cref="T:Cake.Common.Build.GitLabCI.GitLabCIProvider" /> instance that can be used to
/// obtain information from the GitLab CI environment.
/// </summary>
/// <example>
/// <code>
/// var isGitLabCIBuild = GitLabCI.IsRunningOnGitLabCI;
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="N:Cake.Common.Build.GitLabCI" /> instance.</returns>
private Cake.Common.Build.GitLabCI.IGitLabCIProvider _GitLabCI;
public Cake.Common.Build.GitLabCI.IGitLabCIProvider GitLabCI
{
get
{
if (_GitLabCI==null)
{
_GitLabCI = Cake.Common.Build.BuildSystemAliases.GitLabCI(Context);
}
return _GitLabCI;
}
}
/// <summary>
/// Gets a <see cref="T:Cake.Common.Build.TFBuild.TFBuildProvider" /> instance that can be used to
/// obtain information from the Team Foundation Build environment.
/// </summary>
/// <example>
/// <code>
/// var isTFSBuild = TFBuild.IsRunningOnTFS;
/// </code>
/// </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="N:Cake.Common.Build.TFBuild" /> instance.</returns>
private Cake.Common.Build.TFBuild.ITFBuildProvider _TFBuild;
public Cake.Common.Build.TFBuild.ITFBuildProvider TFBuild
{
get
{
if (_TFBuild==null)
{
_TFBuild = Cake.Common.Build.BuildSystemAliases.TFBuild(Context);
}
return _TFBuild;
}
}
#line 1 "C:/src/gh/omnisharp-roslyn/test-assets/test-projects/CakeProject/build.cake"
#line 1 "C:/src/gh/omnisharp-roslyn/test-assets/test-projects/CakeProject/foo.cake"
Information("Hello World");
#line 1 "C:/src/gh/omnisharp-roslyn/test-assets/test-projects/CakeProject/build.cake"
// #load foo.cake
Information("Hello World");
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment