private IEnumerable <TargetRelativePath> GetDependencyResults(IBuildContext context, IBuilder node)
{
var referenceBuilder = node as IReferenceBuilder;
if (referenceBuilder != null)
{
foreach (var depSource in context.GetResults(referenceBuilder))
{
foreach (var project in slnBuilder.Projects)
{
if (project.References.Contains(referenceBuilder.Reference))
{
// We expect the msbuild compilation to copy these dependencies to the module target directory
yield return(new TargetRelativePath(project.RelativeTargetPath, Path.GetFileName(depSource.RelativePath)));
}
}
}
}
else
{
foreach (var result in context.GetDependencies(node).SelectMany(child => GetDependencyResults(context, child)))
{
yield return(result);
}
}
}
/// <summary>
/// Runs this builder
/// </summary>
/// <param name="context"> </param>
/// <returns>Returns a set of generated files, in suite relative paths</returns>
public override ISet <TargetRelativePath> Run(IBuildContext context)
{
var vcxprojPath = project.Name + ".vcxproj";
const string csversionPath = "version.cpp";
var csversion = project.GetVersionSupport() ? project.RootDirectory.CreateTextFile(csversionPath) : null;
using (var fsproj = project.RootDirectory.GetChildDirectory("cpp").CreateTextFile(vcxprojPath))
{
var references = new HashSet <TargetRelativePath>();
foreach (var refBuilder in context.GetDependencies(this).OfType <IReferenceBuilder>().Where(r => r.Reference.Type == ReferenceType.Build))
{
var builderResults = context.GetResults(refBuilder);
references.UnionWith(builderResults);
}
generator.Generate(project, references, fsproj, csversion, csversionPath);
}
if (csversion != null)
{
csversion.Close();
csversion.Dispose();
}
return(new HashSet <TargetRelativePath>(
new[]
{
new TargetRelativePath(String.Empty,
suite.SuiteRoot.GetRelativePathFrom(targetDir,
Path.Combine(suite.SuiteRoot.GetRelativePath(project.RootDirectory), "cpp", vcxprojPath))),
}));
}
/// <summary>
/// Prepares a builder to be ran in a given build context.
///
/// <para>This is the place where a builder can add additional dependencies.</para>
/// </summary>
/// <param name="context">The current build context</param>
public void AddToContext(IBuildContext context)
{
var moduleName = reference.Uri.Host;
var projectName = reference.Uri.AbsolutePath.TrimStart('/');
if (suite.HasModule(moduleName))
{
var module = suite.GetModule(moduleName);
referencedProject = module.GetProjectOrTestProject(projectName);
if (!context.Contains(this))
{
if (referencedProject != null)
{
subtasks = new HashSet <IBuilder>();
context.AddBuilder(this, SubtaskGenerator(context));
}
else
{
throw new InvalidReferenceException(string.Format("Module {0} has no project called {1}",
moduleName, projectName));
}
}
else
{
subtasks = new HashSet <IBuilder>(context.GetDependencies(this));
}
}
else
{
throw new InvalidReferenceException(string.Format("Suite has no module called {0}", moduleName));
}
}
public IEnumerable <IBuilder> GetDependencies(IBuilder builder)
{
var resolved = ResolveBuilder(builder);
var converted = ConvertBuilder(resolved);
return(baseContext.GetDependencies(converted ?? resolved));
}
/// <summary>
/// Runs this builder
/// </summary>
/// <param name="context"> </param>
/// <returns>Returns a set of generated files, in suite relative paths</returns>
public override ISet <TargetRelativePath> Run(IBuildContext context)
{
var fsprojPath = project.Name + ".fsproj";
const string fsversionPath = "version.fs";
using (var fsproj = project.RootDirectory.GetChildDirectory("fs").CreateTextFile(fsprojPath))
using (var fsversion = project.RootDirectory.CreateTextFile(fsversionPath))
{
var references = new HashSet <TargetRelativePath>();
foreach (var refBuilder in context.GetDependencies(this).OfType <IReferenceBuilder>().Where(r => r.Reference.Type == ReferenceType.Build))
{
var builderResults = context.GetResults(refBuilder);
references.UnionWith(builderResults);
}
generator.Generate(project, references, fsproj, fsversion, fsversionPath);
}
return(new HashSet <TargetRelativePath>(
new[]
{
new TargetRelativePath(String.Empty,
suite.SuiteRoot.GetRelativePathFrom(targetDir,
Path.Combine(suite.SuiteRoot.GetRelativePath(project.RootDirectory), "fs", fsprojPath))),
new TargetRelativePath(String.Empty,
suite.SuiteRoot.GetRelativePathFrom(targetDir,
Path.Combine(suite.SuiteRoot.GetRelativePath(project.RootDirectory), fsversionPath)))
}));
}
/// <summary>
/// Prepares a builder to be ran in a given build context.
///
/// <para>This is the place where a builder can add additional dependencies.</para>
/// </summary>
/// <param name="context">The current build context</param>
public void AddToContext(IBuildContext context)
{
builders.Clear();
if (alias != null && !context.Contains(this))
{
foreach (var childRef in alias.References)
{
if (childRef.Type == reference.Type)
{
var builder = referenceBuilderFactory.CreateReferenceBuilder(childRef, project);
builder.AddToContext(context);
builders.Add(builder);
}
}
context.AddBuilder(this, builders);
}
else
{
foreach (var dep in context.GetDependencies(this))
{
builders.Add(dep);
}
}
}
/// <summary>
/// Prepares a builder to be ran in a given build context.
///
/// <para>This is the place where a builder can add additional dependencies.</para>
/// </summary>
/// <param name="context">The current build context</param>
public void AddToContext(IBuildContext context)
{
if (!context.Contains(this))
{
referenceBuilders = new HashSet <IBuilder>(project.References.Select(CreateReferenceBuilder));
foreach (var refBuilder in referenceBuilders)
{
refBuilder.AddToContext(context);
}
context.AddBuilder(this, referenceBuilders);
}
else
{
referenceBuilders = new HashSet <IBuilder>(context.GetDependencies(this));
}
}
/// <summary>
/// Prepares a builder to be ran in a given build context.
///
/// <para>This is the place where a builder can add additional dependencies.</para>
/// </summary>
/// <param name="context">The current build context</param>
public void AddToContext(IBuildContext context)
{
if (!context.Contains(this))
{
log.DebugFormat("Creating reference builders for {0}", project.Name);
referenceBuilders = new HashSet <IBuilder>(
project.References.Where(r => r.Type == ReferenceType.Build).Select(CreateReferenceBuilder));
foreach (var refBuilder in referenceBuilders)
{
refBuilder.AddToContext(context);
}
context.AddBuilder(this, referenceBuilders);
log.DebugFormat("{0} added to build context", project.Name);
}
else
{
referenceBuilders = new HashSet <IBuilder>(context.GetDependencies(this));
}
}
/// <summary>
/// Prepares a builder to be ran in a given build context.
///
/// <para>This is the place where a builder can add additional dependencies.</para>
/// </summary>
/// <param name="context">The current build context</param>
public void AddToContext(IBuildContext context)
{
if (!context.Contains(this))
{
var solutionBuildContext = new SolutionBuildContext(inSolutionReferenceBuilderFactory, context, this);
projectBuilders = new HashSet <ISlnProjectBuilder>(
from project in projects
select CreateProjectBuilder(solutionBuildContext, project)
into builder
where builder != null
select builder
);
solutionBuildContext.AddBuilder(this, projectBuilders);
}
else
{
projectBuilders = new HashSet <ISlnProjectBuilder>(context.GetDependencies(this).Cast <ISlnProjectBuilder>());
}
projectDependencies = MultipleDependenciesHelper.CreateMultipleDependencies(new HashSet <IBuilder>(projectBuilders));
}
/// <summary>
/// Runs this builder
/// </summary>
/// <param name="context"> </param>
/// <returns>Returns a set of generated files, in suite relative paths</returns>
public override ISet <TargetRelativePath> Run(IBuildContext context)
{
var csprojPath = project.Name + ".csproj";
const string csversionPath = "version.cs";
using (var csproj = project.RootDirectory.GetChildDirectory("cs").CreateTextFile(csprojPath))
using (var csversion = project.RootDirectory.CreateTextFile(csversionPath))
{
var references = new HashSet <TargetRelativePath>();
foreach (var refBuilder in context.GetDependencies(this).OfType <IReferenceBuilder>().Where(r => r.Reference.Type == ReferenceType.Build))
{
try
{
var builderResults = context.GetResults(refBuilder);
references.UnionWith(builderResults);
}
catch (InvalidOperationException ex)
{
log.ErrorFormat("Failed to get results of reference {0}: {1}", refBuilder, ex.Message);
throw;
}
}
generator.Generate(project, references, csproj, csversion, csversionPath);
}
return(new HashSet <TargetRelativePath>(
new[]
{
new TargetRelativePath(String.Empty,
suite.SuiteRoot.GetRelativePathFrom(targetDir,
Path.Combine(suite.SuiteRoot.GetRelativePath(project.RootDirectory), "cs", csprojPath))),
new TargetRelativePath(String.Empty,
suite.SuiteRoot.GetRelativePathFrom(targetDir,
Path.Combine(suite.SuiteRoot.GetRelativePath(project.RootDirectory), csversionPath)))
}));
}
/// <summary>
/// Prepares a builder to be ran in a given build context.
///
/// <para>This is the place where a builder can add additional dependencies.</para>
/// </summary>
/// <param name="context">The current build context</param>
public void AddToContext(IBuildContext context)
{
string projectName = reference.Uri.Host;
referencedProject = module.GetProjectOrTestProject(projectName);
if (!context.Contains(this))
{
if (referencedProject != null)
{
subtasks = new HashSet <IBuilder>();
context.AddBuilder(this, SubtaskGenerator(context));
}
else
{
throw new InvalidReferenceException(string.Format("Module {0} has no project called {1}",
module.Name, projectName));
}
}
else
{
subtasks = new HashSet <IBuilder>(context.GetDependencies(this));
}
}
