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)); }