public void Render(ITableBuilder tableBuilder, object model, RenderingTemplate template)
{
if (!TypeCheckingHelper.IsEnumerable(model.GetType()))
{
throw new ArgumentException("model is not IEnumerable");
}
var enumerableToRender = ((IEnumerable)model).Cast <object>().ToArray();
for (var i = 0; i < enumerableToRender.Length; ++i)
{
var element = enumerableToRender[i];
var normalizedElement = NormalizeElement(element);
tableBuilder.PushState();
var renderer = rendererCollection.GetRenderer(normalizedElement.GetType());
renderer.Render(tableBuilder, normalizedElement, template);
tableBuilder.PopState();
if (i != enumerableToRender.Length - 1)
{
tableBuilder.MoveToNextLayer();
}
}
}
/// <summary>
/// Type checks all <param name="codes"/> as part of the same module with default parsing options and asserts no errors are present
/// </summary>
public static void TypeCheckAndAssertNoErrors(this string[] codes)
{
var diagnostics = TypeCheckingHelper.GetSemanticDiagnostics(
parsingOptions: DefaultParsingOptions,
implicitReferenceModule: true, codes: codes);
Assert.Empty(diagnostics);
}
public IEnumerableParser GetEnumerableParser(Type modelType)
{
if (TypeCheckingHelper.IsEnumerable(modelType))
{
return(new EnumerableParser(this));
}
throw new InvalidOperationException($"{modelType} is not IEnumerable");
}
/// <summary>
/// Type checks all <param name="codes"/> as part of the same module with default parsing options and asserts there is a single
/// outcoming error that contains substring <param name="messageSubstring"/>
/// </summary>
public static void TypeCheckAndAssertSingleError(this string[] codes, string messageSubstring)
{
var diagnostics = TypeCheckingHelper.GetSemanticDiagnostics(
parsingOptions: DefaultParsingOptions,
implicitReferenceModule: true, codes: codes);
Assert.Equal(1, diagnostics.Count);
Assert.True(diagnostics.First().MessageText.ToString().Contains(messageSubstring));
}
public void IdentifiersAreNotEscapedIfEscapingIsTurnedOff()
{
var diagnostics = TypeCheckingHelper.GetSemanticDiagnostics(
parsingOptions: ParsingOptions.GetDefaultParsingOptionsWithEscapeIdentifiers(false),
implicitReferenceModule: true,
codes: BrandingAssignment);
Assert.Empty(diagnostics);
}
public void IdentifiersAreEscaped()
{
var diagnostics = TypeCheckingHelper.GetSemanticDiagnostics(
parsingOptions: ParsingOptions.GetDefaultParsingOptionsWithEscapeIdentifiers(true),
implicitReferenceModule: true,
codes: BrandingAssignment);
Assert.Single(diagnostics);
}
private List <Diagnostic> TestWithoutToolOption(string code)
{
var diagnostics = TypeCheckingHelper.GetSemanticDiagnostics(parsingOptions: ParsingOptions.DefaultParsingOptions, implicitReferenceModule: true, codes: code);
foreach (var d in diagnostics)
{
m_output.WriteLine(d.ToString());
}
return(diagnostics);
}
private List <Diagnostic> GetDiagnostics(string code, bool implicitRefenceModule = true)
{
var diagnostics = TypeCheckingHelper.GetSemanticDiagnostics(
parsingOptions: ParsingOptions,
implicitReferenceModule: implicitRefenceModule,
codes: code);
foreach (var d in diagnostics)
{
m_output.WriteLine(d.ToString());
}
return(diagnostics);
}
private Dictionary <ExcelTemplatePath, int> GetEnumerablesLengths <TModel>([NotNull] ITableParser tableParser, [NotNull] RenderingTemplate template)
{
var enumerableCellsGroups = new Dictionary <ExcelTemplatePath, List <ICell> >();
foreach (var row in template.Content.Cells)
{
foreach (var cell in row)
{
var expression = cell.StringValue;
if (TemplateDescriptionHelper.IsCorrectValueDescription(expression) && ExcelTemplatePath.FromRawExpression(expression).HasArrayAccess)
{
var cleanPathToEnumerable = ExcelTemplatePath.FromRawExpression(expression)
.SplitForEnumerableExpansion()
.pathToEnumerable
.WithoutArrayAccess();
if (!enumerableCellsGroups.ContainsKey(cleanPathToEnumerable))
{
enumerableCellsGroups[cleanPathToEnumerable] = new List <ICell>();
}
enumerableCellsGroups[cleanPathToEnumerable].Add(cell);
}
}
}
var enumerablesLengths = new Dictionary <ExcelTemplatePath, int>();
foreach (var enumerableCells in enumerableCellsGroups)
{
var cleanPathToEnumerable = enumerableCells.Key;
var childEnumerableType = ObjectPropertiesExtractor.ExtractChildObjectTypeFromPath(typeof(TModel), cleanPathToEnumerable);
if (!TypeCheckingHelper.IsIList(childEnumerableType))
{
throw new InvalidOperationException($"Only ILists are supported as collections, but tried to use '{childEnumerableType}'. (path: {cleanPathToEnumerable.RawPath})");
}
var primaryParts = enumerableCells.Value.Where(x => ExcelTemplatePath.FromRawExpression(x.StringValue).HasPrimaryKeyArrayAccess).ToList();
if (primaryParts.Count == 0)
{
primaryParts = enumerableCells.Value.Take(1).ToList();
}
var measurer = parserCollection.GetEnumerableMeasurer();
enumerablesLengths[cleanPathToEnumerable] = measurer.GetLength(tableParser, typeof(TModel), primaryParts);
}
return(enumerablesLengths);
}
public IRenderer GetRenderer([NotNull] Type modelType)
{
if (modelType == typeof(string))
{
return(new StringRenderer());
}
if (modelType == typeof(int))
{
return(new IntRenderer());
}
if (modelType == typeof(decimal))
{
return(new DecimalRenderer());
}
if (modelType == typeof(double))
{
return(new DoubleRenderer());
}
if (TypeCheckingHelper.IsEnumerable(modelType))
{
return(new EnumerableRenderer(this));
}
return(new ClassRenderer(templateCollection, this));
}
/// <summary>
/// Loads lib.core.d.ts and sets it as the prelude
/// </summary>
public TestChecker SetDefaultPrelude()
{
return(SetPrelude(TypeCheckingHelper.ParseLib()));
}
