public static string PrettifyMemberInfo([NotNull] MemberInfo memberInfo, [NotNull] PrettificationSettings settings)
{
var typeName = memberInfo.DeclaringType?.PrettifyType(settings).Suffix(".");
var memberName = memberInfo.Name;
return($"{typeName}{memberName}".WithTypeLabel(memberInfo.GetType(), settings));
}
private static string _Prettify_Lambda([NotNull] Delegate del, [NotNull] PrettificationSettings settings)
{
var typeStr = del.GetType().Prettify(settings);
var nameStr = del.GetMethodInfo().Name;
return($"{LambdaIcon} {typeStr} => {nameStr}");
}
public static string PrettifyFileSystemInfo([NotNull] FileSystemInfo item, [CanBeNull] PrettificationSettings settings = default)
{
settings ??= Prettification.DefaultPrettificationSettings;
return(settings.PreferredLineStyle == LineStyle.Single
? PrettifySingleItem(item, settings)
: PrettifyWithChildren(item, settings).JoinLines());
}
private static string PrettifyGenericType([CanBeNull] Type genericType, [CanBeNull] PrettificationSettings settings)
{
if (genericType?.IsGenericType != true)
{
throw new ArgumentException($"{genericType} is not a generic type!", nameof(genericType));
}
// Make sure to use `.GetGenericArguments()` and not `.GenericTypeArguments`, because the latter will return an empty array for
// a generic type definition like `List<>`
var genArgs = genericType.GetGenericArguments();
return(genericType.Name.Replace($"`{genArgs.Length}", PrettifyGenericTypeArguments(genArgs, settings)));
}
private static object GetHeader(
[NotNull, ItemCanBeNull]
IEnumerable values,
[CanBeNull] Type valueType,
[NotNull] string fallback,
[NotNull] PrettificationSettings settings
)
{
return(settings.HeaderStyle.Value switch {
HeaderStyle.None => fallback,
HeaderStyle.TypeNames => valueType ?? InferType(values),
_ => throw BEnum.InvalidEnumArgumentException(nameof(settings.HeaderStyle), settings.HeaderStyle.Value)
});
public IEnumerable <string> GetLines([CanBeNull] PrettificationSettings settings)
{
settings ??= Prettification.DefaultPrettificationSettings.JsonClone();
// calculate the various widths
var keyLines = Keys.GetLines(settings).ToArray();
var valLines = Vals.GetLines(settings).ToArray();
var(keyWidth, valWidth) = CalculateWidths(keyLines.LongestLine(), valLines.LongestLine(), settings.TableColumnSeparator, settings.LineLengthLimit);
var limitedKeyLines = keyLines.Select(it => it.Truncate(keyWidth)).ToArray();
var limitedValLines = valLines.Select(it => it.Truncate(valWidth)).ToArray();
return(limitedKeyLines.Select((keyLine, i) => $"{keyLine}{settings.TableColumnSeparator}{limitedValLines[i]}"));
}
public static string PrettifyType([CanBeNull] this Type type, [CanBeNull] PrettificationSettings settings)
{
settings ??= Prettification.DefaultPrettificationSettings;
if (type == null)
{
return(settings.NullPlaceholder);
}
if (type.IsTupleType())
{
return(PrettifyTupleType(type, settings));
}
// if the type is generic, we need to trim the `n and replace it with the generic type arguments
return(type.IsGenericTypeOrDefinition() ? PrettifyGenericType(type, settings) : type.NameOrKeyword());
}
public void PrettifyType(Type actualType, string expected_full, string expected_short, string expected_none)
{
var settings_full = new PrettificationSettings()
{
TypeLabelStyle = { Value = TypeNameStyle.Full }
};
var settings_short = new PrettificationSettings()
{
TypeLabelStyle = { Value = TypeNameStyle.Short }
};
var settings_none = new PrettificationSettings()
{
TypeLabelStyle = { Value = TypeNameStyle.None }
};
Console.WriteLine(
new[] {
public IEnumerable <string> GetLines(PrettificationSettings settings)
{
settings ??= Prettification.DefaultPrettificationSettings;
settings = settings.JsonClone();
settings.PreferredLineStyle.Set(LineStyle.Single);
var prettyCells = Cells.Select(it => it.Prettify(settings)).ToList();
if (Header != null)
{
var headerStr = Header.Prettify(settings);
int longestCell = prettyCells.LongestLine();
int longestLine = longestCell.Max(headerStr.Length);
var separatorLine = (settings.TableHeaderSeparator.Value ?? " ").Fill(longestLine);
return(new[] {
headerStr,
separatorLine
}.Concat(prettyCells));
}
return(prettyCells);
}
public static string PrettifyEnumerable(
[NotNull][ItemCanBeNull]
IEnumerable enumerable,
[NotNull] PrettificationSettings settings
)
{
var asObjects = enumerable.Cast <object>();
var enumerableType = enumerable.GetType();
var lineStyle = settings?.PreferredLineStyle.Value ?? default;
var innerSettings = settings.JsonClone(
it => {
it.EnumLabelStyle.Set(TypeNameStyle.None);
it.TypeLabelStyle.Set(it.TypeLabelStyle.Value.Reduce());
}
);
return(lineStyle switch {
LineStyle.Dynamic => PrettifyEnumerable_DynamicLine(asObjects, enumerableType, settings, innerSettings),
LineStyle.Multi => PrettifyEnumerable_MultiLine(asObjects, enumerableType, settings, innerSettings),
LineStyle.Single => PrettifyEnumerable_SingleLine(asObjects, enumerableType, settings, innerSettings),
_ => throw BEnum.InvalidEnumArgumentException(nameof(PrettificationSettings.PreferredLineStyle), lineStyle)
});
private static string BuildMessage(
[NotNull] IEnumerable <object> superset,
IEnumerable <object>?valuesThatShouldBeThere,
string?messagePrefix
)
{
PrettificationSettings prettySettings = new PrettificationSettings()
{
TypeLabelStyle = { Value = TypeNameStyle.Full }
};
var badValues = valuesThatShouldBeThere?.Except(superset);
return(new Dictionary <object, object>()
{
[superset.GetType().PrettifyType(prettySettings)] = superset,
[nameof(valuesThatShouldBeThere)] = valuesThatShouldBeThere,
["Disallowed values"] = badValues
}.Prettify(prettySettings)
.SplitLines()
.PrependNonNull(messagePrefix)
.JoinLines());
}
private static string GetNickname([CanBeNull] Delegate dgate, [CanBeNull] IResolveConstraint constraint, [CanBeNull] PrettificationSettings settings)
{
var dName = dgate?.Prettify(settings);
var cName = constraint?.Prettify(settings);
var parts = new[] { dName, cName };
return(parts.NonBlank().JoinString(" 🗜 "));
}
private static IEnumerable <string> EnumerateChildren([NotNull] DirectoryInfo dir, [CanBeNull] PrettificationSettings settings, int depthLimit, int currentDepth)
{
return(dir.EnumerateFileSystemInfos()
.SelectMany(it => PrettifyWithChildren(it, settings, depthLimit, currentDepth)));
}
public static string PrettifyMethodInfo([NotNull] MethodInfo methodInfo, [NotNull] PrettificationSettings settings)
{
return($"{PrettifyMemberInfo(methodInfo, settings)}({PrettifyParameters(methodInfo, settings)})");
}
private static string StylizeGenericTypeArguments([NotNull, ItemCanBeNull] IEnumerable <Type> genericTypeArguments, [CanBeNull] PrettificationSettings settings)
{
settings ??= Prettification.DefaultPrettificationSettings;
return(settings.TypeLabelStyle.Value switch {
TypeNameStyle.None => "",
TypeNameStyle.Full => genericTypeArguments.Select(it => it.PrettifyType(settings)).JoinString(", "),
TypeNameStyle.Short => genericTypeArguments.Select(_ => "").JoinString(","),
_ => throw BEnum.InvalidEnumArgumentException(nameof(settings.TypeLabelStyle.Value), settings.TypeLabelStyle.Value)
});
private static string PrettifyGenericTypeArguments([NotNull, ItemNotNull] IEnumerable <Type> genericTypeArguments, [CanBeNull] PrettificationSettings settings)
{
var stylizedArgs = StylizeGenericTypeArguments(genericTypeArguments, settings);
return($"<{stylizedArgs}>");
}
private static string PrettifyTupleType(Type tupleType, [CanBeNull] PrettificationSettings settings)
{
var genArgs = tupleType.GetGenericArguments().Select(it => it.PrettifyType(settings));
return($"({genArgs.JoinString(", ")})");
}
private static string PrettifyParameters([NotNull] MethodBase methodInfo, [NotNull] PrettificationSettings settings)
{
return(methodInfo.GetParameters()
.Select(it => PrettifyParameterInfo(it, settings))
.JoinString(", "));
}
public static string PrettifyParameterInfo([NotNull] ParameterInfo parameterInfo, [NotNull] PrettificationSettings settings)
{
return(WithTypeLabel(parameterInfo.Name, parameterInfo.ParameterType, settings));
}
private static string _Prettify_MethodReference([NotNull] Delegate methodReference, [NotNull] PrettificationSettings settings)
{
//TODO: Remove this roundabout logic once we have a proper way to copy settings, such as using a fancy-schmancy new record
var labelStyleModified = settings.TypeLabelStyle.HasValue == false;
if (labelStyleModified)
{
settings.TypeLabelStyle.Set(TypeNameStyle.None);
}
var methodInfo = PrettifyMethodInfo(methodReference.Method, settings);
if (labelStyleModified)
{
settings.TypeLabelStyle.Unset();
}
return($"{MethodIcon} {methodInfo}");
}
private static IMultipleAsserter ComparingFallbacks <T>(Fallback <T> actual, Fallback <T> expected, [CanBeNull] PrettificationSettings asserterPrettificationSettings = default)
{
return(Asserter.Against(actual)
.WithHeading($"Comparing {nameof(Fallback<T>)}s")
.WithPrettificationSettings(asserterPrettificationSettings)
.And(
Is.EqualTo(expected)
.Using(new FallbackComparer()),
() => typeof(FallbackComparer).Prettify(asserterPrettificationSettings)
));
}
internal static Func <string> GetNicknameSupplier([CanBeNull] Delegate dgate, [CanBeNull] IResolveConstraint constraint, [CanBeNull] PrettificationSettings settings = default)
{
return(() => GetNickname(dgate, constraint, settings));
}
internal static string PrettifyEnum([NotNull] Enum enm, [NotNull] PrettificationSettings settings)
{
settings = Prettification.ResolveSettings(settings);
return(enm.ToString().WithTypeLabel(enm.GetType(), settings, "."));
}
public static string PrettifyDelegate([NotNull] Delegate del, [NotNull] PrettificationSettings settings)
{
return(del.IsCompilerGenerated() ? _Prettify_Lambda(del, settings) : _Prettify_MethodReference(del, settings));
}
