/// <summary>
/// Translate the unit into TypeScript.
/// </summary>
/// <returns></returns>
public string Translate()
{
FormatWriter writer = new FormatWriter()
{
Formatter = this.Formatter
};
if (this.hasGet)
{
// Opening declaration: [<modifiers>] get <name>() : <type> {
// TODO: Handle case of no visibility specified
writer.WriteLine("{0}{1}{2} {3} {4}{5}",
this.RenderedModifiers,
this.RenderedGetterMethodName,
Lexems.OpenRoundBracket + Lexems.CloseRoundBracket,
Lexems.Colon,
this.type.Translate(),
this.hasSet ? Lexems.Semicolon : string.Empty); // TODO: Find a better way for this
}
if (this.hasSet)
{
var valueParameter = ArgumentDefinitionTranslationUnit.Create(
this.type, IdentifierTranslationUnit.Create("value"));
// Opening declaration: [<modifiers>] set <name>(value : <type>) : void {
// Emitting `void` in order to prevent errors in case of implicitAllowAny
writer.WriteLine("{0}{1}{2}{3}{4} {5} {6}",
this.RenderedModifiers,
this.RenderedSetterMethodName,
Lexems.OpenRoundBracket,
valueParameter.Translate(),
Lexems.CloseRoundBracket,
Lexems.Colon,
Lexems.VoidReturnType);
}
return(writer.ToString());
}
/// <summary>
/// Following typical scheme.
/// </summary>
/// <returns></returns>
public string Translate()
{
FormatWriter writer = new FormatWriter()
{
Formatter = this.Formatter
};
// Opening
writer.WriteLine("{0} {1}",
HeaderLexem,
Lexems.OpenCurlyBracket);
foreach (var translationUnit in this.innerUnits)
{
writer.WriteLine("{0}",
translationUnit.Translate());
}
// Closing
writer.WriteLine("{0}",
Lexems.CloseCurlyBracket);
return(writer.ToString());
}
internal static void FormatHeaders(FormatWriter formatWriter, KeyValuePair <string, string[]>[] headers)
{
StringBuilder buf = formatWriter.FieldBuffer;
foreach (var header in headers)
{
foreach (string value in header.Value)
{
buf.Clear();
buf.Append(" ");
buf.Append(header.Key);
buf.Append(": ");
buf.Append(value);
formatWriter.WriteLine(buf, ColorCategory.Debug);
}
}
}
/// <inheritdoc />
public override void Format(ref HttpRequestEntry entry, FormatWriter formatWriter)
{
StringBuilder buf = formatWriter.FieldBuffer;
formatWriter.BeginEntry(0);
// RequestNumber
buf.Clear();
buf.Append(entry.RequestNumber);
buf.Append('>');
formatWriter.WriteField(buf, ColorCategory.Markup, 3);
formatWriter.WriteTimestamp(entry.RequestStarted, ColorCategory.Detail);
formatWriter.WriteField(entry.Method, ColorCategory.Info, 3);
formatWriter.WriteField(entry.Uri, ColorCategory.Important);
FormatterHelper.FormatHeaders(formatWriter, entry.RequestHeaders);
formatWriter.WriteLine(); // Extra line break for readability
formatWriter.EndEntry();
formatWriter.IndentLevel++;
}
/// <summary>
/// Formats <paramref name="untypedDictionary"/> as dictionary with key type <typeparamref name="TKey"/> and value type <typeparamref name="TValue"/>.
/// </summary>
/// <param name="untypedDictionary"></param>
/// <param name="formatWriter"></param>
/// <param name="recursionLevel"></param>
/// <param name="lineage"></param>
/// <param name="parentPropertyType">The type of the property set to object <paramref name="untypedDictionary"/>. May be <c>null</c> if not applicable or unknown.</param>
/// <returns>The max <paramref name="recursionLevel"/> reached when <paramref name="untypedDictionary"/> was formatted.</returns>
// ReSharper disable once UnusedMember.Local
private int FormatAsDictionary <TKey, TValue>(object untypedDictionary, FormatWriter formatWriter, int recursionLevel, Stack <object> lineage, Type parentPropertyType)
{
// OK that this throws on failure; this shouldn't happen
var dictionary = (IEnumerable <KeyValuePair <TKey, TValue> >)untypedDictionary;
int maxRecursionLevel = recursionLevel;
if (!dictionary.Any())
{
formatWriter.WriteField("{}", ColorCategory.Markup);
return(recursionLevel);
}
else
{
formatWriter.WriteField("{", ColorCategory.Markup);
formatWriter.IndentLevel += 1;
bool onFirstKvp = true;
Type dictionaryType = dictionary.GetType();
if (IncludeTypeNames && (parentPropertyType != dictionaryType))
{
formatWriter.WriteField("type:", ColorCategory.Debug);
formatWriter.WriteText(_typeNameFunc(dictionaryType), ColorCategory.Debug);
onFirstKvp = false;
}
foreach (var kvp in dictionary)
{
if (!onFirstKvp)
{
formatWriter.WriteText(",", ColorCategory.Markup);
}
formatWriter.WriteEndLine();
onFirstKvp = false;
formatWriter.WriteField("{", ColorCategory.Markup);
formatWriter.IndentLevel += 1;
// If key is primitive, format on single line
TKey key = kvp.Key;
TValue value = kvp.Value;
int childMaxRecursionLevel;
if (ShouldFormatAsPrimitive(key))
{
formatWriter.WriteText(formatWriter.FieldDelimiter, ColorCategory.Markup);
FormatAsPrimitive(key, formatWriter);
formatWriter.WriteText(":", ColorCategory.Markup);
childMaxRecursionLevel = InnerFormatObject(value, formatWriter, recursionLevel + 1, lineage, typeof(TValue));
}
else
{
formatWriter.WriteField("Key", ColorCategory.Detail);
formatWriter.WriteText(":", ColorCategory.Markup);
childMaxRecursionLevel = InnerFormatObject(key, formatWriter, recursionLevel + 1, lineage, typeof(TKey));
maxRecursionLevel = Math.Max(maxRecursionLevel, childMaxRecursionLevel);
formatWriter.WriteText(",", ColorCategory.Markup);
formatWriter.WriteEndLine();
formatWriter.WriteField("Value", ColorCategory.Detail);
formatWriter.WriteText(":", ColorCategory.Markup);
childMaxRecursionLevel = InnerFormatObject(value, formatWriter, recursionLevel + 1, lineage, typeof(TValue));
}
maxRecursionLevel = Math.Max(maxRecursionLevel, childMaxRecursionLevel);
if (!ShouldFormatAsPrimitive(value))
{
formatWriter.WriteLine();
}
formatWriter.IndentLevel -= 1;
formatWriter.WriteField("}", ColorCategory.Markup);
}
formatWriter.WriteEndLine();
formatWriter.IndentLevel -= 1;
formatWriter.WriteField("}", ColorCategory.Markup);
}
return(maxRecursionLevel);
}
/// <summary>
/// Formats <paramref name="o"/> as an object.
/// </summary>
/// <param name="o"></param>
/// <param name="formatWriter"></param>
/// <param name="recursionLevel"></param>
/// <param name="lineage"></param>
/// <param name="parentPropertyType">The type of the property set to value <paramref name="o"/>. May be <c>null</c> if not applicable or unknown.</param>
/// <returns>The max <paramref name="recursionLevel"/> reached when <paramref name="o"/> was formatted.</returns>
private int FormatAsObject(object o, FormatWriter formatWriter, int recursionLevel, Stack <object> lineage, Type parentPropertyType)
{
int maxRecursionLevel = recursionLevel;
formatWriter.WriteField("{", ColorCategory.Markup);
if (recursionLevel > 0)
{
formatWriter.WriteEndLine();
}
formatWriter.IndentLevel += 1;
Type objectType = o.GetType();
if (IncludeTypeNames && (parentPropertyType != objectType))
{
formatWriter.WriteField("type:", ColorCategory.Debug);
formatWriter.WriteText(_typeNameFunc(objectType), ColorCategory.Debug);
formatWriter.WriteLine();
}
// Write properties
foreach (var property in objectType.GetReadablePublicProperties())
{
bool colonWritten = false;
void WriteErrorAsPropertyValue(string errorMessage)
{
if (!colonWritten)
{
formatWriter.WriteText(":", ColorCategory.Markup);
}
formatWriter.WriteText("!(", ColorCategory.Markup);
formatWriter.WriteText(errorMessage, ColorCategory.Warning);
formatWriter.WriteText(")!", ColorCategory.Markup);
}
try
{
formatWriter.WriteField(property.Name, ColorCategory.Detail);
Type propertyType = property.PropertyType;
ParameterInfo[] propertyIndexParameters = property.GetIndexParameters();
if (propertyIndexParameters.Length > 0)
{
// Properties with index parameters are not formatted - they act like functions, it's not possible to enumerate all contained values.
WriteErrorAsPropertyValue("Properties with index parameters are not formatted");
continue;
}
// GetValue(object) throws if the property has index parameters
object propertyValue = property.GetValue(o);
if (IncludeTypeNames)
{
// Only write the propertyType if it doesn't equal the subobject type
bool writePropertyType = !object.ReferenceEquals(propertyValue?.GetType(), propertyType);
if (writePropertyType)
{
formatWriter.WriteText("(", ColorCategory.Markup);
formatWriter.WriteText(_typeNameFunc(propertyType), ColorCategory.Debug);
formatWriter.WriteText(")", ColorCategory.Markup);
}
}
formatWriter.WriteText(":", ColorCategory.Markup);
colonWritten = true;
int propertyMaxRecursionLevel = InnerFormatObject(propertyValue, formatWriter, recursionLevel + 1, lineage, propertyType);
maxRecursionLevel = Math.Max(maxRecursionLevel, propertyMaxRecursionLevel);
}
catch (Exception excp)
{ // Exception reading or formatting the property value.
WriteErrorAsPropertyValue(excp.ToString());
}
}
// No newline for simple objects with no sub-objects
if (maxRecursionLevel > 1)
{
formatWriter.WriteEndLine();
}
formatWriter.IndentLevel -= 1;
formatWriter.WriteField("}", ColorCategory.Markup);
return(maxRecursionLevel);
}
/// <inheritdoc />
public override void Format(ref HttpResponseEntry entry, FormatWriter formatWriter)
{
StringBuilder buf = formatWriter.FieldBuffer;
formatWriter.IndentLevel--;
formatWriter.BeginEntry(0);
// RequestNumber
buf.Clear();
buf.Append(entry.RequestNumber);
buf.Append('<');
formatWriter.WriteField(buf, ColorCategory.Markup, 3);
formatWriter.WriteTimestamp(entry.RequestCompleted, ColorCategory.Detail);
// Ttfb
buf.Clear();
buf.AppendPadZeroes(entry.Ttfb.Seconds, 2);
buf.Append('.');
buf.AppendPadZeroes(entry.Ttfb.Milliseconds, 3);
buf.Append('s');
formatWriter.WriteField(buf, ColorCategory.Info);
// Determine response color from HTTP status code
ColorCategory responseColorCategory = ColorCategory.None;
if (formatWriter.IsColorEnabled)
{
var statusCode = entry.HttpStatusCode;
if ((statusCode >= 200) && (statusCode < 300))
{
responseColorCategory = ColorCategory.Success;
}
else if ((statusCode >= 300) && (statusCode < 400))
{
responseColorCategory = ColorCategory.Important;
}
else if (statusCode >= 500)
{
responseColorCategory = ColorCategory.Error;
}
else
{
responseColorCategory = ColorCategory.Warning;
}
}
formatWriter.WriteField(entry.Method, ColorCategory.Info, 3);
formatWriter.WriteField(entry.Uri, responseColorCategory);
formatWriter.WriteLine();
// HTTP status line
formatWriter.WriteLinePrefix(formatWriter.IndentLevel + 1);
formatWriter.WriteText(" HTTP/1.1 ", ColorCategory.Detail);
buf.Clear();
buf.Append(entry.HttpStatusCode);
formatWriter.WriteText(buf, 0, buf.Length, responseColorCategory);
formatWriter.WriteSpaces(1);
formatWriter.WriteText(entry.HttpReasonPhrase, ColorCategory.Detail);
formatWriter.WriteLine();
FormatterHelper.FormatHeaders(formatWriter, entry.ResponseHeaders);
formatWriter.WriteLine(); // Extra line break for readability
formatWriter.EndEntry();
}
