Add options to allow label customisation and easier filtering

Breaking: changes `CsvDefinition` from a `KeyValuePair<string, Func<T, string>>` to a custom `CsvField<T>` for simplicity to add more functionailty.

- Adds option for overiding a label on `CsvDefinition` fields (key and label can now be different)
- Adds option to provide an include function, to determine if the column should render or not (allows for simpler conditionally included columns)

Author: davetransom

CSharpVitamins.Tabulation.Tests/CSharpVitamins.Tabulation.Tests.csproj

@@ -190,6 +190,7 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="CsvFieldFacts.cs" />
     <Compile Include="CsvDefinitionFacts.cs" />
     <Compile Include="PlainTextTableFacts.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />

CSharpVitamins.Tabulation.Tests/CsvFieldFacts.cs

@@ -0,0 +1,77 @@
+using CSharpVitamins.Tabulation;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+using Xunit.Abstractions;
+using Xunit.Extensions;
+
+//namespace CSharpVitamins.Tabulation.Tests
+namespace Tests
+{
+	public class CsvFieldFacts
+	{
+		ITestOutputHelper output;
+
+		public CsvFieldFacts(ITestOutputHelper output)
+		{
+			this.output = output;
+		}
+
+		class DemoModel
+		{
+			public string FieldA { get; set; }
+			public string FieldB { get; set; }
+			public string FieldC { get; set; }
+			public string FieldD { get; set; }
+		}
+
+		IList<DemoModel> create_data()
+		{
+			return new[]
+			{
+				new DemoModel { FieldA = "Row 1 A", FieldB = "B1", FieldC = "C1", FieldD = "D1" },
+				new DemoModel { FieldA = "Row 2 A", FieldB = "B2", FieldC = "C2" },
+				new DemoModel { FieldA = "Row 3 A" }
+			};
+		}
+
+		CsvDefinition<DemoModel> create_definition()
+		{
+			return new CsvDefinition<DemoModel>
+			{
+				{ "Field A", "Field A Label", item => item.FieldA },
+				{ "Field B", item => item.FieldB },
+				{ "Field C", item => item.FieldC, x => false },
+				{ "Field D", "D Field", item => item.FieldD, x => true },
+				{ "Field B", "", item => item.FieldB },
+				{ "Field C", "Field C Again", item => item.FieldC },
+			};
+		}
+
+		[Fact]
+		void observes_includedFields_and_labels()
+		{
+			var fields = create_definition();
+			var data = create_data();
+
+			string result;
+			using (var writer = new StringWriter())
+			{
+				fields.Write(writer, data, " | ");
+				result = writer.ToString();
+			}
+
+			const string expected = "Field A Label | Field B | D Field |  | Field C Again"
+				+ "\r\nRow 1 A | B1 | D1 | B1 | C1"
+				+ "\r\nRow 2 A | B2 |  | B2 | C2"
+				+ "\r\nRow 3 A |  |  |  | "
+				+ "\r\n";
+
+			Assert.Equal(expected, result);
+		}
+	}
+}

CSharpVitamins.Tabulation/CSharpVitamins.Tabulation.csproj

@@ -41,6 +41,7 @@
   <ItemGroup>
     <Compile Include="Alignment.cs" />
     <Compile Include="ColumnState.cs" />
+    <Compile Include="CsvField.cs" />
     <Compile Include="Divider.cs" />
     <Compile Include="CsvDefinitionFactory.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />

CSharpVitamins.Tabulation/CSharpVitamins.Tabulation.nuspec

@@ -12,6 +12,10 @@
 `CharpVitamins.Tabulation` provides helpers to create tabular data with little fuss i.e. Tab or comma separated values (`CsvDefinition`), 
 or padded columns of plain text (via `PlainTextTable`).</description>
     <releaseNotes>
+* 2.0.0: Breaking: changes `CsvDefinition` from a `KeyValuePair&lt;string, Func&lt;T, string&gt;&gt;` to a custom `CsvField&lt;T&gt;` for simplicity to add more functionailty.
+         Adds option for overiding a label on `CsvDefinition` fields (key and label can now be different)
+         Adds option to provide an include function, to determine if the column should render or not (allows for simpler conditionally included columns)
+
 * 1.0.3: Now throws `ArgumentNullException` for non-nullable params to the `CsvDefinition.Write()` method
 * 1.0.2: Meta data update
 * 1.0.1: Adds `PlainTextTable.Divide()` method as a quick way to append a new divider.
@@ -20,4 +24,4 @@ or padded columns of plain text (via `PlainTextTable`).</description>
     <copyright>Copyright 2015</copyright>
     <tags>CSV Text PlainText</tags>
   </metadata>
-</package>
+</package>

CSharpVitamins.Tabulation/CsvDefinition.cs

@@ -9,20 +9,29 @@ namespace CSharpVitamins.Tabulation
 	/// Creates a definition of fields to be used as a tabular output
 	/// </summary>
 	/// <typeparam name="T"></typeparam>
-	public class CsvDefinition<T> : List<KeyValuePair<string, Func<T, string>>>
+	public class CsvDefinition<T> : List<CsvField<T>>
 	{
+		/// <summary />
 		public CsvDefinition()
 			: base()
 		{ }
 
+		/// <summary />
 		public CsvDefinition(int capacity)
 			: base(capacity)
 		{ }
 
-		public CsvDefinition(IEnumerable<KeyValuePair<string, Func<T, string>>> items)
+		/// <summary />
+		public CsvDefinition(IEnumerable<CsvField<T>> items)
 			: base(items)
 		{ }
 
+		// backwards compat
+		/// <summary />
+		public CsvDefinition(IEnumerable<KeyValuePair<string, Func<T, string>>> items)
+			: base(items.Cast<CsvField<T>>())
+		{ }
+
 		/// <summary>
 		/// If the header has been output
 		/// </summary>
@@ -44,17 +53,54 @@ public void Reset()
 		/// <returns>True if the key was found.</returns>
 		public bool Contains(string key, StringComparison comparison = StringComparison.Ordinal)
 		{
-			return this.FindIndex(x => string.Equals(x.Key, key, comparison)) != -1;
+			return this.FindIndex(
+				x => string.Equals(x.Key, key, comparison)
+			) != -1;
 		}
 
 		/// <summary>
 		/// Adds a Key/Value pair to the definition - used for easy object initialisation
 		/// </summary>
 		/// <param name="key">The name of the column/header</param>
-		/// <param name="value">The Func to convert T into a string for the column value</param>
-		public void Add(string key, Func<T, string> value)
+		/// <param name="picker">The Func to convert T into a string for the column value</param>
+		public void Add(string key, Func<T, string> picker)
+		{
+			Add(new CsvField<T>(key, picker));
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="label"></param>
+		/// <param name="picker"></param>
+		public void Add(string key, string label, Func<T, string> picker)
+		{
+			Add(new CsvField<T>(key, picker) { Label = label });
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="label"></param>
+		/// <param name="picker"></param>
+		/// <param name="include"></param>
+		public void Add(string key, Func<T, string> picker, Func<string, bool> include)
 		{
-			Add(new KeyValuePair<string, Func<T, string>>(key, value));
+			Add(new CsvField<T>(key, picker) { Include = include, });
+		}
+
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="label"></param>
+		/// <param name="picker"></param>
+		/// <param name="include"></param>
+		public void Add(string key, string label, Func<T, string> picker, Func<string, bool> include)
+		{
+			Add(new CsvField<T>(key, picker) { Label = label, Include = include, });
 		}
 
 		/// <summary>
@@ -65,7 +111,10 @@ public void Add(string key, Func<T, string> value)
 		/// <returns>True if the field was found and removed, otherwise false</returns>
 		public bool Remove(string key, StringComparison comparison = StringComparison.Ordinal)
 		{
-			var index = this.FindIndex(x => string.Equals(x.Key, key, comparison));
+			var index = this.FindIndex(
+				x => string.Equals(x.Key, key, comparison)
+			);
+
 			if (index == -1)
 				return false;
 
@@ -81,37 +130,46 @@ public bool Remove(string key, StringComparison comparison = StringComparison.Or
 		/// <param name="delimiter">The string to delimit column values with. A single character delimiter isare also used to escape the value, multi-character strings are not escaped.</param>
 		public void Write(TextWriter writer, IEnumerable<T> rows, string delimiter = ",")
 		{
-			if (writer == null)
+			if (null == writer)
 				throw new ArgumentNullException(nameof(writer));
 
-			if (rows == null)
+			if (null == rows)
 				throw new ArgumentNullException(nameof(rows));
 
-			if (delimiter == null)
+			if (null == delimiter)
 				throw new ArgumentNullException(nameof(delimiter));
 
 			char[] escChars = delimiter.Length == 1
 				? new[] { delimiter[0], '\n', '\r', '"' }
 				: new[] { '\n', '\r', '"' };
 
+			var columns = this
+				.Where(
+					x => x.ShouldInclude
+				)
+				.ToArray();
+
 			if (!HeaderWritten)
 			{
 				HeaderWritten = true;
 
-				string header = string.Join(delimiter, this.Select(
-					x => Escape(x.Key, escChars)
-				));
+				string header = string.Join(
+					delimiter,
+					columns.Select(
+						x => Escape(x.Label ?? x.Key, escChars)
+					)
+				);
 				writer.WriteLine(header);
 			}
 
 			foreach (T row in rows)
 			{
 				string line = string.Join(
 					delimiter,
-					this.Select(
-						x => Escape(x.Value(row), escChars) // x.Value == Func<T, string>
-				));
-
+					columns.Select(
+						x => Escape(x.PickValue(row), escChars)
+					)
+				);
 				writer.WriteLine(line);
 			}
 		}
@@ -138,12 +196,26 @@ public PlainTextTable Tabulate(IEnumerable<T> rows, PlainTextTable tab = null)
 			if (null == tab)
 				tab = new PlainTextTable();
 
-			string[] line = this.Select(x => x.Key).ToArray();
+			var columns = this
+				.Where(
+					x => x.ShouldInclude
+				)
+				.ToArray();
+
+			string[] line = columns
+				.Select(
+					x => x.Label ?? x.Key
+				)
+				.ToArray();
 			tab.AddRow(line); // header
 
 			foreach (T row in rows)
 			{
-				line = this.Select(x => x.Value(row)).ToArray();
+				line = columns
+					.Select(
+						x => x.PickValue(row)
+					)
+					.ToArray();
 				tab.AddRow(line);
 			}
 

CSharpVitamins.Tabulation/CsvDefinitionFactory.cs

@@ -22,6 +22,9 @@ public class CsvDefinitionFactory
 		public static Func<PropertyInfo, string> FailoverNameConverter =
 			(prop) => prop.Name;
 
+		/// <summary />
+		Func<PropertyInfo, bool> shouldInclude = prop => true;
+
 		/// <summary>
 		/// 
 		/// </summary>
@@ -43,6 +46,15 @@ public CsvDefinitionFactory()
 		/// </summary>
 		public IDictionary<Type, Func<PropertyInfo, object, string>> ValueConverters { get; set; }
 
+		/// <summary>
+		/// Takes the details for a property and returns if the property should be included as a column (cannot be null)
+		/// </summary>
+		public Func<PropertyInfo, bool> ShouldInclude
+		{
+			get => shouldInclude;
+			set => shouldInclude = value ?? throw new NullReferenceException($"{nameof(ShouldInclude)} cannot be set to `null`");
+		}
+
 		/// <summary>
 		/// Resolves the value converter for the type
 		/// </summary>
@@ -61,24 +73,25 @@ static Func<PropertyInfo, object, string> resolve_converter(Type type, IDictiona
 		/// <summary>
 		/// Creates a definition from the given model's properties (prop.Name &amp; prop.Value.ToString())
 		/// </summary>
-		/// <typeparam name="T">The model to reflect on</typeparam>
+		/// <typeparam name="Model">The model to reflect on</typeparam>
 		/// <returns>A TableDefinition instance that can render rows of data given the model T</returns>
-		public CsvDefinition<T> CreateFromModel<T>()
+		public CsvDefinition<Model> CreateFromModel<Model>()
 		{
 			var nameOf = NameConverter ?? FailoverNameConverter;
 
-			return new CsvDefinition<T>(
-				typeof(T)
+			return new CsvDefinition<Model>(
+				typeof(Model)
 					.GetProperties()
-					.Select(prop => 
+					.Where(ShouldInclude)
+					.Select(prop =>
 					{
 						var converter = resolve_converter(prop.PropertyType, this.ValueConverters);
 
-						return new KeyValuePair<string, Func<T, string>>(
+						return new CsvField<Model>(
 							nameOf(prop),
-							x =>
+							model =>
 							{
-								object value = prop.GetValue(x, null);
+								object value = prop.GetValue(model, null);
 								return converter(prop, value);
 							}
 						);