private static IEnumerable <TargetDefinition> GetDependencies(
TargetDefinition targetDefinition,
IReadOnlyDictionary <string, TargetDefinition> nameDictionary,
IReadOnlyDictionary <Target, TargetDefinition> factoryDictionary)
{
return(targetDefinition.NamedDependencies
.Select(x => nameDictionary.TryGetValue(x, out var namedTarget)
? namedTarget
: TargetDefinition.Create(x))
.Concat(targetDefinition.FactoryDependencies.Select(x => factoryDictionary[x])));
}
private static IEnumerable <TargetDefinition> GetDependencies(
TargetDefinition targetDefinition,
IReadOnlyDictionary <string, TargetDefinition> nameDictionary,
IReadOnlyDictionary <Target, TargetDefinition> factoryDictionary)
{
return(targetDefinition.ShadowTargetDependencies
.Select(shadowTargetName => nameDictionary.TryGetValue(shadowTargetName, out var shadowTarget)
? shadowTarget
: TargetDefinition.Create(shadowTargetName))
.Concat(targetDefinition.TargetDependencies.Select(x => factoryDictionary[x])));
}
public static IReadOnlyCollection <ExecutableTarget> CreateAll <T>(
T build,
params Expression <Func <T, Target> >[] defaultTargetExpressions)
where T : NukeBuild
{
var buildType = build.GetType();
var targetProperties = GetTargetProperties(build.GetType()).ToList();
var defaultTargets = defaultTargetExpressions.Select(x => x.Compile().Invoke(build)).ToList();
ExecutableTarget Create(PropertyInfo property)
{
var baseMembers = buildType
.Descendants(x => x.BaseType)
.Select(x => x.GetProperty(property.Name))
.Where(x => x != null && x.DeclaringType == x.ReflectedType)
.Reverse().ToList();
var definition = new TargetDefinition(property, build, new Stack <PropertyInfo>(baseMembers));
var factory = (Target)property.GetValue(build);
factory.Invoke(definition);
return(new ExecutableTarget
{
Name = property.GetDisplayShortName(),
Member = property,
Definition = definition,
Description = definition.Description,
Factory = factory,
IsDefault = defaultTargets.Contains(factory),
DynamicConditions = definition.DynamicConditions,
StaticConditions = definition.StaticConditions,
DependencyBehavior = definition.DependencyBehavior,
ProceedAfterFailure = definition.IsProceedAfterFailure,
AssuredAfterFailure = definition.IsAssuredAfterFailure,
Requirements = definition.Requirements,
Actions = definition.Actions,
Listed = !definition.IsInternal,
PartitionSize = definition.PartitionSize,
ArtifactProducts = definition.ArtifactProducts
});
}
var executables = targetProperties.Select(Create).ToList();
executables.ForEach(x => ApplyDependencies(x, executables));
return(executables);
}
private static IEnumerable <TargetDefinition> GetDependencies(
TargetDefinition targetDefinition,
IReadOnlyDictionary <Target, TargetDefinition> factoryDictionary)
{
foreach (var target in targetDefinition.FactoryDependencies.Select(x => factoryDictionary[x]))
{
yield return(target);
}
foreach (var target in targetDefinition.RunAfterTargets.Select(x => factoryDictionary[x]))
{
yield return(target);
}
foreach (var target in factoryDictionary.Values.Where(x => x.RunBeforeTargets.Contains(targetDefinition.Factory)))
{
yield return(target);
}
}
private static void SkipTargetAndDependencies(
TargetDefinition targetDefinition,
IReadOnlyCollection <TargetDefinition> invokedTargets,
IReadOnlyCollection <TargetDefinition> executingTargets,
IDictionary <TargetDefinition, List <TargetDefinition> > skipRequestDictionary = null)
{
skipRequestDictionary = skipRequestDictionary ?? new Dictionary <TargetDefinition, List <TargetDefinition> >();
targetDefinition.Skip = true;
foreach (var dependency in targetDefinition.TargetDefinitionDependencies)
{
if (invokedTargets.Contains(dependency))
{
continue;
}
var skipRequests = skipRequestDictionary.GetValueOrDefault(dependency);
if (skipRequests == null)
{
skipRequests = skipRequestDictionary[dependency] = new List <TargetDefinition>();
}
var executingDependentTargets = executingTargets
.Where(x => x != targetDefinition)
.Where(x => x.TargetDefinitionDependencies.Contains(dependency) && !skipRequests.Contains(x));
if (executingDependentTargets.Any())
{
skipRequests.Add(targetDefinition);
}
else
{
SkipTargetAndDependencies(dependency, invokedTargets, executingTargets, skipRequestDictionary);
}
}
}
public static IReadOnlyCollection <ExecutableTarget> CreateAll <T>(
T build,
params Expression <Func <T, Target> >[] defaultTargetExpressions)
where T : NukeBuild
{
var defaultTargets = defaultTargetExpressions.Select(x => x.Compile().Invoke(build)).ToList();
var properties = build.GetType()
.GetProperties(ReflectionService.Instance)
.Where(x => x.PropertyType == typeof(Target)).ToList();
var executables = new List <ExecutableTarget>();
foreach (var property in properties)
{
var factory = (Target)property.GetValue(build);
var definition = new TargetDefinition();
factory.Invoke(definition);
var target = new ExecutableTarget
{
Name = property.Name,
Member = property,
Definition = definition,
Description = definition.Description,
Factory = factory,
IsDefault = defaultTargets.Contains(factory),
DynamicConditions = definition.DynamicConditions,
StaticConditions = definition.StaticConditions,
DependencyBehavior = definition.DependencyBehavior,
ProceedAfterFailure = definition.IsProceedAfterFailure,
AssuredAfterFailure = definition.IsAssuredAfterFailure,
Requirements = definition.Requirements,
Actions = definition.Actions,
Listed = !definition.IsInternal
};
executables.Add(target);
}
foreach (var executable in executables)
{
IEnumerable <ExecutableTarget> GetDependencies(
Func <TargetDefinition, IReadOnlyList <Target> > directDependenciesSelector,
Func <TargetDefinition, IReadOnlyList <Target> > indirectDependenciesSelector)
{
foreach (var factoryDependency in directDependenciesSelector(executable.Definition))
{
yield return(executables.Single(x => x.Factory == factoryDependency));
}
foreach (var otherExecutables in executables.Where(x => x != executable))
{
var otherDependencies = indirectDependenciesSelector(otherExecutables.Definition);
if (otherDependencies.Any(x => x == executable.Factory))
{
yield return(otherExecutables);
}
}
}
executable.ExecutionDependencies.AddRange(GetDependencies(x => x.DependsOnTargets, x => x.DependentForTargets));
executable.OrderDependencies.AddRange(GetDependencies(x => x.AfterTargets, x => x.BeforeTargets));
executable.TriggerDependencies.AddRange(GetDependencies(x => x.TriggeredByTargets, x => x.TriggersTargets));
executable.Triggers.AddRange(GetDependencies(x => x.TriggersTargets, x => x.TriggeredByTargets));
}
return(executables);
}
private static TargetDefinition LoadTargetDefinition(NukeBuild build, PropertyInfo property)
{
var targetFactory = (Target)property.GetValue(build);
return(TargetDefinition.Create(property.Name, targetFactory));
}
private static string GetDeclaration(this TargetDefinition targetDefinition)
{
return(targetDefinition.IsDefault
? $"defaultTarget[{targetDefinition.Name}]"
: targetDefinition.Name);
}
