public static void RegisterInitTask(IBootstrapTask task)
{
if (_tasks == null)
_tasks = new List<object>();
_tasks.Add(task);
}
public virtual void Register(IBootstrapTask task)
{
if (task != null)
{
Tasks.Add(task);
}
}
private void ProcessExports(BootstrapTaskDescriptor descriptor, IBootstrapTask task)
{
foreach (IDependencyExportDescriptor exportDescriptor in descriptor.Exports)
{
context.DependencyExporter.Export(exportDescriptor, exportDescriptor.GetValue(task));
}
}
public string GenerateTask(IBootstrapTask bootstrapTask)
{
StringBuilder taskString = new StringBuilder();
taskString.AppendLine("<UsingTask");
taskString.AppendLine("\tTaskName=\"BootstrapMsBuildByConvention\"");
taskString.AppendLine("\tTaskFactory=\"CodeTaskFactory\"");
taskString.AppendLine("\tAssemblyFile=\"$(MSBuildToolsPath)\\Microsoft.Build.Tasks.v4.0.dll\">");
taskString.AppendLine("\t<ParameterGroup>");
if (bootstrapTask.TaskParameters != null)
{
foreach (TaskParameter taskParameter in bootstrapTask.TaskParameters)
{
taskString.AppendFormat(
"\t\t<{0} ParameterType=\"{1}\" Output=\"{2}\"></{0}>\n", taskParameter.Name, taskParameter.Type, taskParameter.IsOutput.ToString().ToLowerInvariant());
}
}
taskString.AppendLine("\t</ParameterGroup>");
taskString.AppendLine("\t<Task>");
List <string> usings = bootstrapTask.GenerateUsings();
string code = bootstrapTask.GenerateCSharpCode();
this.AddUsings(taskString, usings);
this.AddCode(taskString, code);
taskString.AppendLine("\t</Task>");
taskString.AppendLine("</UsingTask>");
return(taskString.ToString());
}
public void Initialize()
{
IBootstrapTask task = factory();
if (task != null)
{
task.Initialize();
}
}
public void Register(IBootstrapTask task)
{
Ensure.NotNull(task, "task");
BootstrapTaskDescriptor descriptor = new BootstrapTaskDescriptor(task.GetType());
descriptor.Imports.AddRange(context.DescriptorProvider.GetImports(descriptor.Type));
descriptor.Exports.AddRange(context.DescriptorProvider.GetExports(descriptor.Type));
descriptor.Instance = task;
descriptors.Add(descriptor);
}
public void GenerateTaskShouldReturnValidMsBuildStatement()
{
//Arrange
string projectXmlString =
"<Project xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\" ToolsVersion=\"4.0\">\n{0}\n</Project>";
this._bootstrapTask = new BootstrapTask();
//Act
string project = string.Format(projectXmlString, this._taskCodeGenerator.GenerateTask(this._bootstrapTask));
//Assert
Assert.That(() => new Project(new XmlTextReader(new StringReader(project))), Throws.Nothing);
}
public void GenerateTaskShouldCallIBootstrapTask()
{
//Arrange
IBootstrapTask bootstrapTask = MockRepository.GenerateStrictMock <IBootstrapTask>();
bootstrapTask.Expect(obj => obj.TaskParameters).Return(null);
bootstrapTask.Expect(obj => obj.GenerateUsings()).Return(new List <string> {
"System"
});
bootstrapTask.Expect(obj => obj.GenerateCSharpCode())
.Return("Console.WriteLine(string.Join(\" \", Environment.GetCommandLineArgs()));");
//Act
this._taskCodeGenerator.GenerateTask(bootstrapTask);
//Assert
bootstrapTask.VerifyAllExpectations();
}
public override void Initialize()
{
if (types == null)
{
types = FindTypes();
}
foreach (Type type in types)
{
IBootstrapTask instance = CreateInstance(type);
if (AreConstraintsSatisfied(instance))
{
Tasks.Add(instance);
}
}
foreach (IBootstrapTask task in Tasks)
{
task.Initialize();
}
}
/// <summary>
/// Evaluates all constraints in <paramref name="constraints"/>.
/// If any constraint will not satisfies, returns <c>false</c>; if all satisfies, returns <c>true</c>.
/// </summary>
/// <param name="constraints">Constraints to evaluate.</param>
/// <param name="bootstrapTask">Task, where <paramref name="constraints"/> was defined.</param>
/// <param name="context">Context of evaluation.</param>
/// <returns>If any constraint will not satisfies, returns <c>false</c>; if all satisfies, returns <c>true</c>.</returns>
public static bool IsSatisfied(this IEnumerable <IBootstrapConstraint> constraints, IBootstrapTask bootstrapTask, IBootstrapConstraintContext context)
{
foreach (IBootstrapConstraint constraint in constraints)
{
if (!constraint.IsSatisfied(bootstrapTask, context))
{
return(false);
}
}
return(true);
}
public void SetUp()
{
this._bootstrapTask = new BootstrapTask();
}
public void SetUp()
{
this._bootstrapTask = MockRepository.GenerateStub <IBootstrapTask>();
this._taskCodeGenerator = new BootstrapTaskCodeGenerator();
}
protected virtual void InitializeTask(IBootstrapTask task)
{
task.Initialize();
}
protected bool AreConstraintsSatisfied(IBootstrapTask task)
{
IBootstrapConstraintContext context = new DefaultBootstrapConstraintContext(this);
return(provider.GetConstraints(task.GetType()).IsSatisfied(task, context));
}
public object GetValue(IBootstrapTask task)
{
return(TargetProperty.GetValue(task));
}
public bool IsSatisfied(IBootstrapTask task, IBootstrapConstraintContext context)
{
return(!(context.Bootstrapper is AutomaticBootstrapper));
}
public void SetValue(IBootstrapTask task, object dependency)
{
TargetProperty.SetValue(task, dependency);
}
