Example of rich formatting. Formatters also do not have to be formatting failing data, it can be conforming data too

Jake Ginnivan · Jake Ginnivan · commit 8093735a8ff1 · 2013-09-01T11:15:13.000+01:00
diff --git a/TestStack.ConventionTests/Internal/ConventionContext.cs b/TestStack.ConventionTests/Internal/ConventionContext.cs
@@ -28,22 +28,33 @@ public ConventionResult[] ConventionResults
             get { return results.ToArray(); }
         }
 
+        string IConventionFormatContext.FormatDataAsHtml(object data)
+        {
+            var formatter = GetReportDataFormatterFor(data);
+            return formatter.FormatHtml(data);
+        }
+
         ITestResultProcessor IConventionFormatContext.TestResultProcessor
         {
             get { return testResultProcessor; }
         }
 
-        string IConventionFormatContext.FormatDataAsString(object failingData)
+        string IConventionFormatContext.FormatDataAsString(object data)
+        {
+            var formatter = GetReportDataFormatterFor(data);
+
+            return formatter.FormatString(data);
+        }
+
+        IReportDataFormatter GetReportDataFormatterFor(object data)
         {
-            IReportDataFormatter formatter = formatters.FirstOrDefault(f => f.CanFormat(failingData));
+            IReportDataFormatter formatter = formatters.FirstOrDefault(f => f.CanFormat(data));
             if (formatter == null)
             {
                 throw new NoDataFormatterFoundException(
-                    failingData.GetType().Name +
-                    " has no formatter, add one with `Convention.Formatters.Add(new MyDataFormatter());`");
+                    data.GetType().Name + " has no formatter, add one with `Convention.Formatters.Add(new MyDataFormatter());`");
             }
-
-            return formatter.FormatString(failingData);
+            return formatter;
         }
 
         void IConventionResultContext.Is<TResult>(string resultTitle, IEnumerable<TResult> failingData)
diff --git a/TestStack.ConventionTests/Internal/IConventionFormatContext.cs b/TestStack.ConventionTests/Internal/IConventionFormatContext.cs
@@ -4,7 +4,8 @@
 
     public interface IConventionFormatContext
     {
-        string FormatDataAsString(object failingData);
-        ITestResultProcessor TestResultProcessor { get; }
+        string FormatDataAsString(object data);
+        string FormatDataAsHtml(object data);
+        ITestResultProcessor TestResultProcessor { get; }
     }
 }
diff --git a/TestStack.ConventionTests/Reporting/ConvertibleFormatter.cs b/TestStack.ConventionTests/Reporting/ConvertibleFormatter.cs
@@ -6,16 +6,21 @@ namespace TestStack.ConventionTests.Reporting
 
     public class ConvertibleFormatter : IReportDataFormatter
     {
-        public bool CanFormat(object failingData)
+        public bool CanFormat(object data)
         {
-            return failingData is IConvertible;
+            return data is IConvertible;
         }
 
-        public string FormatString(object failingData)
+        public string FormatString(object data)
         {
-            var convertible = failingData as IConvertible;
+            var convertible = data as IConvertible;
             Debug.Assert(convertible != null, "convertible != null");
             return convertible.ToString(CultureInfo.InvariantCulture);
         }
+
+        public string FormatHtml(object data)
+        {
+            return FormatString(data);
+        }
     }
 }
diff --git a/TestStack.ConventionTests/Reporting/FallbackFormatter.cs b/TestStack.ConventionTests/Reporting/FallbackFormatter.cs
@@ -2,16 +2,21 @@
 {
     public class FallbackFormatter : IReportDataFormatter
     {
-        public bool CanFormat(object failingData)
+        public bool CanFormat(object data)
         {
             return true;
         }
 
-        public string FormatString(object failingData)
+        public string FormatString(object data)
         {
-            if (failingData == null)
+            if (data == null)
                 return "<null>";
-            return failingData.ToString();
+            return data.ToString();
+        }
+
+        public string FormatHtml(object data)
+        {
+            return FormatString(data);
         }
     }
 }
diff --git a/TestStack.ConventionTests/Reporting/GroupedByDataTypeRendererBase.cs b/TestStack.ConventionTests/Reporting/GroupedByDataTypeRendererBase.cs
@@ -8,9 +8,9 @@ public abstract class GroupedByDataTypeRendererBase : AggregatedRenderer
     {
         protected override void Process(IConventionFormatContext context)
         {
-            Process(AggregatedReports.OrderBy(c => c.ConventionTitle).GroupBy(r => r.DataDescription));
+            Process(context, AggregatedReports.OrderBy(c => c.ConventionTitle).GroupBy(r => r.DataDescription));
         }
 
-        protected abstract void Process(IEnumerable<IGrouping<string, ConventionResult>> resultsGroupedByDataType);
+        protected abstract void Process(IConventionFormatContext context, IEnumerable<IGrouping<string, ConventionResult>> resultsGroupedByDataType);
     }
 }
diff --git a/TestStack.ConventionTests/Reporting/HtmlReportRenderer.cs b/TestStack.ConventionTests/Reporting/HtmlReportRenderer.cs
@@ -16,25 +16,34 @@ public HtmlReportRenderer(string assemblyDirectory)
             file = Path.Combine(assemblyDirectory, "Conventions.htm");
         }
 
-        protected override void Process(IEnumerable<IGrouping<string, ConventionResult>> resultsGroupedByDataType)
+        protected override void Process(IConventionFormatContext context, IEnumerable<IGrouping<string, ConventionResult>> resultsGroupedByDataType)
         {
             var sb = new StringBuilder();
             var html = new HtmlTextWriter(new StringWriter(sb));
             html.WriteLine("<!DOCTYPE html>");
             html.RenderBeginTag(HtmlTextWriterTag.Html);  // <html>
             html.RenderBeginTag(HtmlTextWriterTag.Head);  // <head>
+
+
+            html.AddAttribute("href", "http://netdna.bootstrapcdn.com/twitter-bootstrap/2.3.2/css/bootstrap-combined.min.css");
+            html.AddAttribute("rel", "stylesheet");
+            html.RenderBeginTag(HtmlTextWriterTag.Link);
+            html.RenderEndTag();
+            html.AddAttribute("href", "http://netdna.bootstrapcdn.com/font-awesome/3.2.1/css/font-awesome.css");
+            html.AddAttribute("rel", "stylesheet");
+
             html.Write(@"
-           <style type=""text/css"">
-               h1 {
-                   color: #3c6eb4;
-               }
+                       <style type=""text/css"">
+                           h1 {
+                               color: #3c6eb4;
+                               border-bottom: 1px solid #3c6eb4;
+                           }
+                       </style>");
+
+            html.RenderBeginTag(HtmlTextWriterTag.Link);
+            html.RenderEndTag();
 
-               h2 {
-                   background: #f1f1f1;
-               }
-           </style>");
             html.RenderEndTag();                          // </head>
-            html.WriteLine();
             html.RenderBeginTag(HtmlTextWriterTag.Body);  // <body>
 
             html.RenderBeginTag(HtmlTextWriterTag.H1);
@@ -43,23 +52,51 @@ protected override void Process(IEnumerable<IGrouping<string, ConventionResult>>
 
             foreach (var conventionReport in resultsGroupedByDataType)
             {
-                html.RenderBeginTag(HtmlTextWriterTag.P);
                 html.RenderBeginTag(HtmlTextWriterTag.Div);
+                html.AddAttribute("style", "margin-left:20px;border-bottom: 1px solid");
                 html.RenderBeginTag(HtmlTextWriterTag.H2);
                 html.Write("Conventions for '<strong>{0}</strong>'", conventionReport.Key);
                 html.RenderEndTag();
-                html.RenderBeginTag(HtmlTextWriterTag.Ul);
                 foreach (var conventionResult in conventionReport)
                 {
-                    html.RenderBeginTag(HtmlTextWriterTag.Li);
+                    var targetId = 
+                        conventionResult.ConventionTitle.Replace("'", string.Empty).Replace(" ", string.Empty).Replace(".", string.Empty) +
+                        conventionResult.DataDescription.Replace("'", string.Empty).Replace(" ", string.Empty).Replace(".", string.Empty);
+                    html.AddAttribute("style", "margin-left:20px;");
+                    html.RenderBeginTag(HtmlTextWriterTag.H4);
+
+                    html.AddAttribute("class", "menu-toggle");
+                    html.AddAttribute("data-toggle", "collapse");
+                    html.AddAttribute("data-target", "." + targetId);
+                    html.RenderBeginTag(HtmlTextWriterTag.A);
+                    html.AddAttribute("class", "icon-angle-down");
+                    html.RenderBeginTag(HtmlTextWriterTag.I);
+                    html.RenderEndTag();
+                    html.RenderEndTag();
                     html.Write(conventionResult.ConventionTitle);
                     html.RenderEndTag();
+                    html.AddAttribute("class", targetId + " collapse");
+                    html.AddAttribute("style", "margin-left:20px;");
+                    html.RenderBeginTag(HtmlTextWriterTag.Div);
+                    html.RenderBeginTag(HtmlTextWriterTag.Ul);
+                    foreach (var o in conventionResult.Data)
+                    {
+                        html.RenderBeginTag(HtmlTextWriterTag.Li);
+                        html.Write(context.FormatDataAsHtml(o));
+                        html.RenderEndTag();
+                    }
+                    html.RenderEndTag();
+                    html.RenderEndTag();
                 }
                 html.RenderEndTag();
-                html.RenderEndTag();
-                html.RenderEndTag();
             }
 
+            html.AddAttribute("src", "http://code.jquery.com/jquery.js");
+            html.RenderBeginTag(HtmlTextWriterTag.Script);
+            html.RenderEndTag();
+            html.AddAttribute("src", "http://netdna.bootstrapcdn.com/twitter-bootstrap/2.3.2/js/bootstrap.min.js");
+            html.RenderBeginTag(HtmlTextWriterTag.Script);
+            html.RenderEndTag();
             html.RenderEndTag();                          // </body>
             html.RenderEndTag();                          // </html>
             html.Flush();
diff --git a/TestStack.ConventionTests/Reporting/IReportDataFormatter.cs b/TestStack.ConventionTests/Reporting/IReportDataFormatter.cs
@@ -2,7 +2,8 @@
 {
     public interface IReportDataFormatter
     {
-        bool CanFormat(object failingData);
-        string FormatString(object failingData);
+        bool CanFormat(object data);
+        string FormatString(object data);
+        string FormatHtml(object data);
     }
 }
diff --git a/TestStack.ConventionTests/Reporting/MarkdownReportRenderer.cs b/TestStack.ConventionTests/Reporting/MarkdownReportRenderer.cs
@@ -15,7 +15,7 @@ public MarkdownReportRenderer(string assemblyDirectory)
             file = Path.Combine(assemblyDirectory, "Conventions.md");
         }
 
-        protected override void Process(IEnumerable<IGrouping<string, ConventionResult>> resultsGroupedByDataType)
+        protected override void Process(IConventionFormatContext context, IEnumerable<IGrouping<string, ConventionResult>> resultsGroupedByDataType)
         {
             var sb = new StringBuilder();
             sb.AppendLine("# Project Conventions");
diff --git a/TestStack.ConventionTests/Reporting/MethodInfoDataFormatter.cs b/TestStack.ConventionTests/Reporting/MethodInfoDataFormatter.cs
@@ -1,19 +1,123 @@
 namespace TestStack.ConventionTests.Reporting
 {
+    using System;
     using System.Reflection;
+    using System.Text;
 
     public class MethodInfoDataFormatter : IReportDataFormatter
     {
-        public bool CanFormat(object failingData)
+        public bool CanFormat(object data)
         {
-            return failingData is MethodInfo;
+            return data is MethodInfo;
         }
 
-        public string FormatString(object failingData)
+        public string FormatString(object data)
         {
-            var methodInfo = (MethodInfo)failingData;
+            var methodInfo = (MethodInfo)data;
 
             return methodInfo.DeclaringType + "." + methodInfo.Name;
         }
+
+        public string FormatHtml(object data)
+        {
+            const string keywordFormat = "<span style=\"color: #0000FF\">{0}</span>";
+            const string typeFormat = "<span style=\"color: #2B91AF\">{0}</span>";
+
+            var methodInfo = (MethodInfo)data;
+            var sb = new StringBuilder();
+            var declaringType = methodInfo.DeclaringType;
+            sb.AppendFormat("{0} {1}.{2} {{ ",
+                string.Format(keywordFormat, "class"),
+                declaringType.Namespace,
+                string.Format(typeFormat, declaringType.Name));
+
+            AppendAccess(methodInfo, sb, keywordFormat);
+
+            if (methodInfo.IsVirtual)
+            {
+                sb.AppendFormat(keywordFormat, "virtual");
+                sb.Append(" ");
+            }
+
+            AppendMethodName(methodInfo, sb);
+            sb.Append(" (...)");
+            sb.Append("}}");
+
+            return sb.ToString();
+        }
+
+        void AppendMethodName(MethodInfo methodInfo, StringBuilder sb)
+        {
+            sb.Append(methodInfo.Name);
+            bool firstParam = true;
+            if (methodInfo.IsGenericMethod)
+            {
+                sb.Append("<");
+                foreach (var g in methodInfo.GetGenericArguments())
+                {
+                    if (firstParam)
+                        firstParam = false;
+                    else
+                        sb.Append(", ");
+                    sb.Append(TypeName(g));
+                }
+                sb.Append(">");
+            }
+        }
+
+        void AppendAccess(MethodInfo method, StringBuilder sb, string format = "{0}")
+        {
+            if (method.IsPublic)
+                sb.AppendFormat(format, "public ");
+            else if (method.IsPrivate)
+                sb.AppendFormat("private ");
+            else if (method.IsAssembly)
+                sb.AppendFormat("internal ");
+            if (method.IsFamily)
+                sb.AppendFormat("protected ");
+            if (method.IsStatic)
+                sb.AppendFormat("static ");
+        }
+
+        static string TypeName(Type type)
+        {
+            var nullableType = Nullable.GetUnderlyingType(type);
+            if (nullableType != null)
+                return nullableType.Name + "?";
+
+            if (!type.IsGenericType)
+                switch (type.Name)
+                {
+                    case "String":
+                        return "string";
+                    case "Int32":
+                        return "int";
+                    case "Decimal":
+                        return "decimal";
+                    case "Object":
+                        return "object";
+                    case "Void":
+                        return "void";
+                    default:
+                        {
+                            return string.IsNullOrWhiteSpace(type.FullName) ? type.Name : type.FullName;
+                        }
+                }
+
+            var sb = new StringBuilder(type.Name.Substring(0,
+            type.Name.IndexOf('`'))
+            );
+            sb.Append('<');
+            var first = true;
+            foreach (var t in type.GetGenericArguments())
+            {
+                if (!first)
+                    sb.Append(',');
+                sb.Append(TypeName(t));
+                first = false;
+            }
+            sb.Append('>');
+            return sb.ToString();
+        }
     }
 }
diff --git a/TestStack.ConventionTests/Reporting/ProjectFileFormatter.cs b/TestStack.ConventionTests/Reporting/ProjectFileFormatter.cs
@@ -4,14 +4,19 @@ namespace TestStack.ConventionTests.Reporting
 
     public class ProjectFileFormatter : IReportDataFormatter
     {
-        public bool CanFormat(object failingData)
+        public bool CanFormat(object data)
         {
-            return failingData is ProjectFileItem;
+            return data is ProjectFileItem;
         }
 
-        public string FormatString(object failingData)
+        public string FormatString(object data)
         {
-            return ((ProjectFileItem)failingData).FilePath;
-        }
+            return ((ProjectFileItem)data).FilePath;
+        }
+
+        public string FormatHtml(object data)
+        {
+            return ((ProjectFileItem) data).FilePath;
+        }
     }
 }
diff --git a/TestStack.ConventionTests/Reporting/ProjectReferenceFormatter.cs b/TestStack.ConventionTests/Reporting/ProjectReferenceFormatter.cs
diff --git a/TestStack.ConventionTests/Reporting/StringDataFormatter.cs b/TestStack.ConventionTests/Reporting/StringDataFormatter.cs
diff --git a/TestStack.ConventionTests/Reporting/TypeDataFormatter.cs b/TestStack.ConventionTests/Reporting/TypeDataFormatter.cs

Original file line number	Diff line number	Diff line change
`@@ -28,22 +28,33 @@ public ConventionResult[] ConventionResults`
`28`	`28`	`get { return results.ToArray(); }`
`29`	`29`	`}`
`30`	`30`
	`31`	`+ string IConventionFormatContext.FormatDataAsHtml(object data)`
	`32`	`+ {`
	`33`	`+ var formatter = GetReportDataFormatterFor(data);`
	`34`	`+ return formatter.FormatHtml(data);`
	`35`	`+ }`
	`36`	`+`
`31`	`37`	`ITestResultProcessor IConventionFormatContext.TestResultProcessor`
`32`	`38`	`{`
`33`	`39`	`get { return testResultProcessor; }`
`34`	`40`	`}`
`35`	`41`
`36`		`- string IConventionFormatContext.FormatDataAsString(object failingData)`
	`42`	`+ string IConventionFormatContext.FormatDataAsString(object data)`
	`43`	`+ {`
	`44`	`+ var formatter = GetReportDataFormatterFor(data);`
	`45`	`+`
	`46`	`+ return formatter.FormatString(data);`
	`47`	`+ }`
	`48`	`+`
	`49`	`+ IReportDataFormatter GetReportDataFormatterFor(object data)`
`37`	`50`	`{`
`38`		`- IReportDataFormatter formatter = formatters.FirstOrDefault(f => f.CanFormat(failingData));`
	`51`	`+ IReportDataFormatter formatter = formatters.FirstOrDefault(f => f.CanFormat(data));`
`39`	`52`	`if (formatter == null)`
`40`	`53`	`{`
`41`	`54`	`throw new NoDataFormatterFoundException(`
`42`		`- failingData.GetType().Name +`
`43`		- " has no formatter, add one with `Convention.Formatters.Add(new MyDataFormatter());`");
	`55`	+ data.GetType().Name + " has no formatter, add one with `Convention.Formatters.Add(new MyDataFormatter());`");
`44`	`56`	`}`
`45`		`-`
`46`		`- return formatter.FormatString(failingData);`
	`57`	`+ return formatter;`
`47`	`58`	`}`
`48`	`59`
`49`	`60`	`void IConventionResultContext.Is<TResult>(string resultTitle, IEnumerable<TResult> failingData)`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,8 @@`
`4`	`4`
`5`	`5`	`public interface IConventionFormatContext`
`6`	`6`	`{`
`7`		`- string FormatDataAsString(object failingData);`
`8`		`- ITestResultProcessor TestResultProcessor { get; }`
	`7`	`+ string FormatDataAsString(object data);`
	`8`	`+ string FormatDataAsHtml(object data);`
	`9`	`+ ITestResultProcessor TestResultProcessor { get; }`
`9`	`10`	`}`
`10`	`11`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,16 +6,21 @@ namespace TestStack.ConventionTests.Reporting`
`6`	`6`
`7`	`7`	`public class ConvertibleFormatter : IReportDataFormatter`
`8`	`8`	`{`
`9`		`- public bool CanFormat(object failingData)`
	`9`	`+ public bool CanFormat(object data)`
`10`	`10`	`{`
`11`		`- return failingData is IConvertible;`
	`11`	`+ return data is IConvertible;`
`12`	`12`	`}`
`13`	`13`
`14`		`- public string FormatString(object failingData)`
	`14`	`+ public string FormatString(object data)`
`15`	`15`	`{`
`16`		`- var convertible = failingData as IConvertible;`
	`16`	`+ var convertible = data as IConvertible;`
`17`	`17`	`Debug.Assert(convertible != null, "convertible != null");`
`18`	`18`	`return convertible.ToString(CultureInfo.InvariantCulture);`
`19`	`19`	`}`
	`20`	`+`
	`21`	`+ public string FormatHtml(object data)`
	`22`	`+ {`
	`23`	`+ return FormatString(data);`
	`24`	`+ }`
`20`	`25`	`}`
`21`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,16 +2,21 @@`
`2`	`2`	`{`
`3`	`3`	`public class FallbackFormatter : IReportDataFormatter`
`4`	`4`	`{`
`5`		`- public bool CanFormat(object failingData)`
	`5`	`+ public bool CanFormat(object data)`
`6`	`6`	`{`
`7`	`7`	`return true;`
`8`	`8`	`}`
`9`	`9`
`10`		`- public string FormatString(object failingData)`
	`10`	`+ public string FormatString(object data)`
`11`	`11`	`{`
`12`		`- if (failingData == null)`
	`12`	`+ if (data == null)`
`13`	`13`	`return "<null>";`
`14`		`- return failingData.ToString();`
	`14`	`+ return data.ToString();`
	`15`	`+ }`
	`16`	`+`
	`17`	`+ public string FormatHtml(object data)`
	`18`	`+ {`
	`19`	`+ return FormatString(data);`
`15`	`20`	`}`
`16`	`21`	`}`
`17`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,9 +8,9 @@ public abstract class GroupedByDataTypeRendererBase : AggregatedRenderer`
`8`	`8`	`{`
`9`	`9`	`protected override void Process(IConventionFormatContext context)`
`10`	`10`	`{`
`11`		`- Process(AggregatedReports.OrderBy(c => c.ConventionTitle).GroupBy(r => r.DataDescription));`
	`11`	`+ Process(context, AggregatedReports.OrderBy(c => c.ConventionTitle).GroupBy(r => r.DataDescription));`
`12`	`12`	`}`
`13`	`13`
`14`		`- protected abstract void Process(IEnumerable<IGrouping<string, ConventionResult>> resultsGroupedByDataType);`
	`14`	`+ protected abstract void Process(IConventionFormatContext context, IEnumerable<IGrouping<string, ConventionResult>> resultsGroupedByDataType);`
`15`	`15`	`}`
`16`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,8 @@`
`2`	`2`	`{`
`3`	`3`	`public interface IReportDataFormatter`
`4`	`4`	`{`
`5`		`- bool CanFormat(object failingData);`
`6`		`- string FormatString(object failingData);`
	`5`	`+ bool CanFormat(object data);`
	`6`	`+ string FormatString(object data);`
	`7`	`+ string FormatHtml(object data);`
`7`	`8`	`}`
`8`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ public MarkdownReportRenderer(string assemblyDirectory)`
`15`	`15`	`file = Path.Combine(assemblyDirectory, "Conventions.md");`
`16`	`16`	`}`
`17`	`17`
`18`		`- protected override void Process(IEnumerable<IGrouping<string, ConventionResult>> resultsGroupedByDataType)`
	`18`	`+ protected override void Process(IConventionFormatContext context, IEnumerable<IGrouping<string, ConventionResult>> resultsGroupedByDataType)`
`19`	`19`	`{`
`20`	`20`	`var sb = new StringBuilder();`
`21`	`21`	`sb.AppendLine("# Project Conventions");`
Original file line number	Diff line number	Diff line change
`@@ -4,14 +4,19 @@ namespace TestStack.ConventionTests.Reporting`
`4`	`4`
`5`	`5`	`public class ProjectFileFormatter : IReportDataFormatter`
`6`	`6`	`{`
`7`		`- public bool CanFormat(object failingData)`
	`7`	`+ public bool CanFormat(object data)`
`8`	`8`	`{`
`9`		`- return failingData is ProjectFileItem;`
	`9`	`+ return data is ProjectFileItem;`
`10`	`10`	`}`
`11`	`11`
`12`		`- public string FormatString(object failingData)`
	`12`	`+ public string FormatString(object data)`
`13`	`13`	`{`
`14`		`- return ((ProjectFileItem)failingData).FilePath;`
`15`		`- }`
	`14`	`+ return ((ProjectFileItem)data).FilePath;`
	`15`	`+ }`
	`16`	`+`
	`17`	`+ public string FormatHtml(object data)`
	`18`	`+ {`
	`19`	`+ return ((ProjectFileItem) data).FilePath;`
	`20`	`+ }`
`16`	`21`	`}`
`17`	`22`	`}`