private static void ApplyStepOverrides(PhasesTemplateReference reference, PhasesTemplate template) { // Select by phase name. var byPhaseNames = (reference.PhaseSelectors ?? new List <PhaseSelector>(0)) .Join(inner: (template.Phases ?? new List <IPhase>(0)).Cast <Phase>(), outerKeySelector: (PhaseSelector phaseSelector) => phaseSelector.Name, innerKeySelector: (Phase phase) => phase.Name, resultSelector: (PhaseSelector phaseSelector, Phase phase) => new { Selector = phaseSelector, Phase = phase }) .ToArray(); // Apply overrides from phase selectors. foreach (var byPhaseName in byPhaseNames) { ApplyStepOverrides(byPhaseName.Selector.StepOverrides, byPhaseName.Phase.Steps); } // Apply unqualified overrides. var allStepLists = (template.Phases ?? new List <IPhase>(0)) .Cast <Phase>() .Select((Phase phase) => phase.Steps ?? new List <IStep>(0)) .Concat(new[] { template.Steps ?? new List <IStep>(0) }) .ToArray(); foreach (List <IStep> stepList in allStepLists) { ApplyStepOverrides(reference.StepOverrides, stepList); } }
public Object ReadYaml(IParser parser, Type type) { var result = new PhasesTemplate(); parser.Expect <MappingStart>(); while (parser.Allow <MappingEnd>() == null) { Scalar scalar = parser.Expect <Scalar>(); switch (scalar.Value ?? String.Empty) { // // Phases template properties // case YamlConstants.Phases: ConverterUtil.ValidateNull(result.Steps, YamlConstants.Steps, YamlConstants.Phases, scalar); result.Phases = ConverterUtil.ReadPhases(parser, simpleOnly: true); break; // // Steps template properties // case YamlConstants.Steps: ConverterUtil.ValidateNull(result.Phases, YamlConstants.Phases, YamlConstants.Steps, scalar); result.Steps = ConverterUtil.ReadSteps(parser, simpleOnly: false); break; default: throw new SyntaxErrorException(scalar.Start, scalar.End, $"Unexpected process property: '{scalar.Value}'"); } } return(result); }
private void ResolveTemplates(IList <IPhase> phases, String defaultRoot, CancellationToken cancellationToken, ref Int32 fileCount) { for (int i = 0; i < (phases?.Count ?? 0);) { if (phases[i] is PhasesTemplateReference) { // Load the template. var reference = phases[i] as PhasesTemplateReference; String templateFilePath = m_fileProvider.ResolvePath(defaultRoot: defaultRoot, path: reference.Name); PipelineFile <PhasesTemplate> templateFile = LoadFile <PhasesTemplate, PhasesTemplateConverter>(templateFilePath, reference.Parameters, cancellationToken, ref fileCount); PhasesTemplate template = templateFile.Object; // Resolve template references within the template. if (template.Steps != null) { ResolveTemplates(template.Steps, defaultRoot: templateFile.Directory, cancellationToken: cancellationToken, fileCount: ref fileCount); } // Merge the template. ApplyStepOverrides(reference, template); phases.RemoveAt(i); if (template.Phases != null) { foreach (IPhase phase in template.Phases) { phases.Insert(i, phase); } i += template.Phases.Count; } else if (template.Steps != null) { var newPhase = new Phase { Steps = template.Steps }; phases.Insert(i, newPhase); i++; } } else { // Resolve nested template references. var phase = phases[i] as Phase; if (phase.Variables != null) { ResolveTemplates(phase.Variables, defaultRoot, cancellationToken, ref fileCount); } if (phase.Steps != null) { ResolveTemplates(phase.Steps, defaultRoot, cancellationToken, ref fileCount); } i++; } } }
internal static void WritePhasesTemplate(IEmitter emitter, PhasesTemplate template, Boolean noBootstrapper = false) { if (!noBootstrapper) { emitter.Emit(new MappingStart()); } if (template.Phases != null && template.Phases.Count > 0) { emitter.Emit(new Scalar(YamlConstants.Phases)); WritePhases(emitter, template.Phases); } WriteStepsTemplate(emitter, template, noBootstrapper: true); if (!noBootstrapper) { emitter.Emit(new MappingEnd()); } }