ITakeValue <T> CreateTargetNode <T>(ITargetDefinition <T> target, Action <Exception> onError)
{
// TODO this smells: generally when you switch on a type like that it's that you should be doing a polymorphic call somewhere else.
// shouldn't it be like that instead:
// - an ActionDefinition know how to create a WriteOnlyNode (which could be renamed ActionNode btw)
// - a MemberDefinition know how to create ReadWriteNode (which could be renamed MemberNode)
// - a FormulaDefinition know how to create ReadOnlyNode (which could be renamed FormulaNode)
// Jake: If we do that the internals need to be opened up and the public API will start bleeding implementation details.
// I think it is better to have the switch?
switch (target.NodeType)
{
case NodeType.Formula:
throw new ArgumentException("Formula nodes cannot be a value target");
case NodeType.Member:
var memberDefinition = (MemberDefinition <T>)target;
var getValueDelegate = memberDefinition.CreateGetValueDelegate();
var setValueDelegate = memberDefinition.CreateSetValueDelegate();
if (!memberDefinition.IsWritable)
{
throw new InvalidOperationException("A readonly member cannot be a target");
}
var shouldTrackChanges = !memberDefinition.SourceType.IsValueType;
var visualisationInfo = new VisualisationInfo(NodeType.Member, IsRoot(memberDefinition));
return(new ReadWriteNode <T>(getValueDelegate, setValueDelegate, target.FullPath, memberDefinition.PathFromParent, visualisationInfo, nodeRepository, shouldTrackChanges, onError));
case NodeType.Action:
return(new WriteOnlyNode <T>(target.CreateSetValueDelegate(), onError, target.FullPath));
default:
throw new ArgumentOutOfRangeException();
}
}
public static ITargetDefinition UseBuildAction <TBuildAction>(this ITargetDefinition targetDefinition, IBuildInfo buildInfo)
where TBuildAction : IBuildAction <TBuildAction>, new()
{
var action = new TBuildAction();
return(action.Setup(targetDefinition, x => x.SetBuildInfo(buildInfo)));
}
public static ITargetDefinition UseBuildAction <TBuildAction>(this ITargetDefinition targetDefinition, Action <TBuildAction> configureAction)
where TBuildAction : IBuildAction <TBuildAction>, new()
{
var action = new TBuildAction();
return(action.Setup(targetDefinition, configureAction));
}
public static ITargetDefinition ExecutesToFolder(this ITargetDefinition targetDefinition, Func <AbsolutePath> output, Func <ICollection <AbsolutePath> > resultsList, Action <AbsolutePath> action)
{
return(targetDefinition.Executes(() =>
{
var artifacts = IBuildSolution.ResultsToFolder(output(), action);
resultsList().AddRange(artifacts);
}));
}
/// <summary>
/// nuget restore
/// </summary>
public static ITargetDefinition Restore(ITargetDefinition _, IXamarinBuild build) => _
.DependsOn(build.Clean)
.Executes(() => DotNetRestore(settings =>
settings
.SetProjectFile(build.Solution)
.SetDisableParallel(true)
.SetDefaultLoggers(build.LogsDirectory / "restore.log")
.SetGitVersionEnvironment(build.GitVersion)));
public static ITargetDefinition Executes <TOutput>(this ITargetDefinition targetDefinition, Func <ICollection <TOutput> > output, Func <IEnumerable <TOutput> > action)
{
return(targetDefinition.Executes(() =>
{
var results = action();
var to = output();
to.AddRange(results);
}));
}
/// <summary>
/// msbuild
/// </summary>
public static ITargetDefinition Build(ITargetDefinition _, IXamarinBuild build) => _
.DependsOn(build.Restore)
.Executes(() => MSBuild(settings =>
settings
.SetSolutionFile(build.Solution)
.SetConfiguration(build.Configuration)
.SetDefaultLoggers(build.LogsDirectory / "build.log")
.SetGitVersionEnvironment(build.GitVersion)
.SetAssemblyVersion(build.GitVersion.AssemblySemVer)
.SetPackageVersion(build.GitVersion.NuGetVersionV2)));
public static ITargetDefinition UseBuildAction <TBuildAction>(this ITargetDefinition targetDefinition, IBuildInfo buildInfo, Action <TBuildAction> configureAction)
where TBuildAction : IBuildAction <TBuildAction>, new()
{
var action = new TBuildAction();
return(action.Setup(targetDefinition,
x =>
{
x.SetBuildInfo(buildInfo);
configureAction(x);
}));
}
/// <summary>
/// nuget restore
/// </summary>
public static ITargetDefinition Restore(ITargetDefinition _, IMsBuild build) => _
.DependsOn(build.Clean)
.Executes(
() =>
{
NuGetTasks
.NuGetRestore(
settings =>
settings
.SetSolutionDirectory(build.Solution)
.EnableNoCache()
);
}
);
ITakeValue <T> GetTargetNode <T>(ITargetDefinition <T> target, Action <Exception> onError)
{
ITakeValue <T> targetNode;
if (definitionToNodeLookup.ContainsKey(target))
{
targetNode = (ITakeValue <T>)definitionToNodeLookup[target];
}
else
{
targetNode = CreateTargetNode(target, onError);
definitionToNodeLookup.Add(target, targetNode);
}
return(targetNode);
}
/// <summary>
/// dotnet restore
/// </summary>
public static ITargetDefinition Restore(ITargetDefinition _, IDotNetCoreBuild build) => _
.Description("Restores the dependencies.")
.DependsOn(build.Clean)
.DependsOn(build.DotnetToolRestore)
.Executes(
() =>
{
DotNetRestore(
s => s
.SetProjectFile(build.Solution)
.SetDisableParallel(true)
.SetDefaultLoggers(build.LogsDirectory / "restore.log")
.SetGitVersionEnvironment(build.GitVersion)
);
}
);
/// <summary>
/// dotnet build
/// </summary>
public static ITargetDefinition Build(ITargetDefinition _, IDotNetCoreBuild build) => _
.Description("Builds all the projects.")
.DependsOn(build.Restore)
.Executes(
() =>
{
DotNetBuild(
s => s
.SetProjectFile(build.Solution)
.SetDefaultLoggers(build.LogsDirectory / "build.log")
.SetGitVersionEnvironment(build.GitVersion)
.SetConfiguration(build.Configuration)
.EnableNoRestore()
);
}
);
/// <summary>
/// nuget pack
/// </summary>
public static ITargetDefinition Pack(ITargetDefinition _, IMsBuild build) => _
.DependsOn(build.Build)
.Executes(
() =>
{
foreach (var project in build.NuspecDirectory.GlobFiles("*.nuspec"))
{
NuGetTasks
.NuGetPack(
settings =>
settings
.SetTargetPath(project)
.SetConfiguration(build.Configuration)
.SetGitVersionEnvironment(build.GitVersion)
.SetVersion(build.GitVersion.NuGetVersionV2)
.SetOutputDirectory(build.NuGetPackageDirectory)
.SetSymbols(true)
);
}
}
);
/// <summary>
/// xunit test
/// </summary>
public static ITargetDefinition Test(ITargetDefinition _, IMsBuild build) => _
.DependsOn(build.Build)
.DependentFor(build.Pack)
.Executes(
() =>
{
foreach (var project in build.Solution.GetTestProjects())
{
DotNetTasks
.DotNetTest(
settings =>
settings
.SetProjectFile(project)
.SetConfiguration(build.Configuration)
.SetGitVersionEnvironment(build.GitVersion)
.SetDefaultLoggers(build.LogsDirectory / "test.log")
.EnableNoRestore()
.SetLogger("trx")
.SetProperty("VSTestResultsDirectory", build.TestResultsDirectory)
);
}
}
);
/// <summary>
/// test
/// </summary>
public static ITargetDefinition Test(ITargetDefinition _, IXamarinBuild build) => _
.DependsOn(build.Build)
.OnlyWhenStatic(() => DirectoryExists(build.TestDirectory))
.Executes(() =>
{
DotNetTest(settings =>
settings
.SetProjectFile(build.Solution)
.SetDefaultLoggers(build.LogsDirectory / "test.log")
.SetGitVersionEnvironment(build.GitVersion)
.SetConfiguration(build.Configuration)
.EnableNoRestore()
.SetLogger($"trx")
.SetProperty("CollectCoverage", "true")
.SetProperty("DeterministicSourcePaths", "false") // DeterministicSourcePaths being true breaks coverlet!
.SetProperty("CoverageDirectory", build.CoverageDirectory)
.SetResultsDirectory(build.TestResultsDirectory));
foreach (var coverage in build.TestResultsDirectory.GlobFiles("**/*.cobertura.xml"))
{
CopyFileToDirectory(coverage, build.CoverageDirectory, FileExistsPolicy.OverwriteIfNewer);
}
});
public void Add <T>(ISourceDefinition <T> source, ITargetDefinition <T> target, Action <Exception> onError)
{
var sourceNode = GetSourceNode(source, onError);
var targetNode = GetTargetNode(target, onError);
sourceNode.VisualisationInfo.IsDirectlyReferenced = true;
targetNode.VisualisationInfo.IsDirectlyReferenced = true;
targetNode.SetSource(sourceNode);
var valueSource = (targetNode) as IValueSource <T>;
if (valueSource != null)
{
var initialValue = valueSource.GetValue();
sourceNode.SetTarget(targetNode, initialValue);
}
graph.AddEdge(sourceNode, targetNode, source.NodeName, target.NodeName);
AddSourcePathExpressions(source, sourceNode, onError);
var targetAsSource = target as ISourceDefinition <T>;
if (targetAsSource != null)
{
AddSourcePathExpressions(targetAsSource, (IValueSource)targetNode, onError);
}
// Formulas should treat all arguments are directly referenced
if (source.NodeType == NodeType.Formula)
{
var successorsOf = graph.PredecessorsOf(sourceNode);
foreach (var edge in successorsOf)
{
edge.Source.Data.VisualisationInfo.IsDirectlyReferenced = true;
}
}
}
public void AddExpression <T>(ISourceDefinition <T> source, ITargetDefinition <T> target, Action <Exception> onError)
{
expressionAdder.Add(source, target, onError);
}
/// <summary>
/// <para>Call a target definition in context of a build script</para>
/// <para>if the build scripts aren't setup correctly the nuke extensions will not detect them.</para>
/// </summary>
/// <typeparam name="T">The value type.</typeparam>
/// <param name="target">The target.</param>
/// <param name="value">The value.</param>
/// <param name="func">The function.</param>
/// <returns>The target definition.</returns>
public static ITargetDefinition With <T>(
this ITargetDefinition target,
T value,
Func <ITargetDefinition, T, ITargetDefinition> func
) => func(target, value);
public TargetDefinitionWrapped(ITargetDefinition inner)
{
Inner = inner;
}
public TargetDefinitionIO(ITargetDefinition inner) : base(inner)
{
}
public static ITargetDefinition Executes(this ITargetDefinition definition, Target target)
{
target(definition);
return(definition);
}
/// <summary> /// dotnet test /// </summary> public static ITargetDefinition Test(ITargetDefinition _, IDotNetCoreBuild build) => Test(true)(_, build);
public static ITargetDefinition ExecuteTarget(this ITargetDefinition targetDefinition, Target target)
{
return(targetDefinition.Executes(() => target.Invoke(targetDefinition)));
}
/// <summary>
/// package
/// </summary>
public static ITargetDefinition Package(ITargetDefinition _, IXamarinBuild build) => _
.DependsOn(build.Test)
.Executes(() => { });
public static ITargetDefinition RunsOnAgent(this ITargetDefinition targetDefinition, params string[] agents)
{
Agents.AddRange(targetDefinition, agents);
return(targetDefinition);
}
public ITargetDefinition Setup(ITargetDefinition targetDefinition)
{
return(Setup(targetDefinition, null));
}
public ITargetDefinition Setup(ITargetDefinition targetDefinition, Action <TBuildAction> configureAction)
{
targetDefinition.Executes(() => ExecuteAction(configureAction));
return(targetDefinition);
}
