/// <summary>
/// Use the format information to return a wrapped and formatted value for a property stack.
/// </summary>
/// <param name="format">The format information that will be used to perform the formatting.</param>
/// <param name="valueObject">The value that will be combined with the heading specified in the <see cref="format"/>.</param>
/// <param name="columnWidth">The width to which the column should be formatted.</param>
/// <param name="tabLength">The number of spaces represented by tab characters.</param>
/// <param name="firstLineHangingIndent">Number of characters at the start of the first line that cannot be used for
/// wrapping. This is required when the wrapped text begins part way along an existing line.</param>
/// <returns>An array of lines containing the formatted output.</returns>
public static string[] Format(ColumnFormat format, object valueObject, int columnWidth, int tabLength = 4, int firstLineHangingIndent = 0)
{
if (valueObject is IConsoleRenderer)
return FormatRenderer(format, valueObject as IConsoleRenderer, columnWidth, tabLength, firstLineHangingIndent);
return FormatStringValue(format, valueObject as string, columnWidth, tabLength, firstLineHangingIndent);
}
private static string[] FormatStringValue(ColumnFormat format, string value, int columnWidth, int tabLength,
int firstLineHangingIndent)
{
var words = WordSplitter.Split(value, tabLength);
var headingText = MakeHeading(format, columnWidth, tabLength, firstLineHangingIndent);
var lastHeadingLineLength = headingText.Last().Length;
var firstLineEffectiveWidth = columnWidth - (headingText.Count() > 1 ? 0 : firstLineHangingIndent);
var numWordsForFirstLine = CountWordsThatFitFirstLine(lastHeadingLineLength, firstLineEffectiveWidth, words);
if (numWordsForFirstLine > 0)
{
var firstLineWords = SplitWord.ConcatenateWords(words.Take(numWordsForFirstLine));
var spaceAvailable = columnWidth - lastHeadingLineLength;
if (firstLineWords.Length < spaceAvailable)
firstLineWords = new string(' ', spaceAvailable - firstLineWords.Length) + firstLineWords;
headingText[headingText.Length - 1] = headingText[headingText.Length - 1] + firstLineWords;
}
if (words.Length == numWordsForFirstLine)
return headingText;
int wrappedLines;
var rest = ColumnWrapper.WrapAndMeasureWords(words.Skip(numWordsForFirstLine), format, columnWidth, 0,
out wrappedLines);
if (format.Alignment == ColumnAlign.Right)
rest = RightAlign(columnWidth, rest);
return headingText.Concat(rest).ToArray();
}
private static string[] FormatRenderer(ColumnFormat format, IConsoleRenderer value, int columnWidth, int tabLength, int firstLineHangingIndent)
{
var headingText = MakeHeading(format, columnWidth, tabLength, firstLineHangingIndent);
int wrappedLines;
var renderedData = value.Render(columnWidth, out wrappedLines);
return headingText.Concat(renderedData).ToArray();
}
public void ValueIsFormatted()
{
var format = new ColumnFormat("Num", Simple.NumberProp.PropertyType);
format.SetActualWidth(5);
var col = new CachedColumn(Simple.NumberProp, 50);
Assert.That(col.Format(format), Is.EqualTo("50"));
}
public static int Max(ColumnFormat format)
{
Func<ColumnFormat, int> func;
if (MaxWidthHandlers.TryGetValue(format.Type, out func))
return func(format);
return DefaultMaxWidth;
}
public void BreaksInVeryLongWordsAreCounted()
{
var c = new ColumnFormat("h", typeof (string));
const string value = "One two three four fivesixseveneightnineteneleven.";
var addedBreaks = ColumnWrapper.CountWordwrapLineBreaks(value, c, 20);
Console.WriteLine(string.Join("\r\n", ColumnWrapper.WrapValue(value, c, 20)));
Assert.That(addedBreaks, Is.EqualTo(2));
}
public void ColourInstructionsAreIncluded()
{
var c = new ColumnFormat("h", typeof (string));
var value = "One".Red() +" " + "two".Blue() + " three\r\nfour five six seven eight\r\n\r\n\r\nnine\r\nten\r\neleven.";
var wrapped = ColumnWrapper.WrapValue(value, c, 20);
var result = FormatResult(value, wrapped, 20);
Console.WriteLine(result);
Approvals.Verify(result);
}
public void ColouredWordsTooLongForALineAreCorrectlyChunked()
{
var c = new ColumnFormat("h", typeof (string));
var value = "toomuchdataforeventwolines".Red();
var wrapped = ColumnWrapper.WrapValue(value, c, 9);
var result = FormatResult(value, wrapped, 10);
Console.WriteLine(result);
Approvals.Verify(result);
}
public void ColouredSpacesAreSkippedAtTheEndOfTheLineButInstructionsArePreserved()
{
var c = new ColumnFormat("h", typeof (string));
var value = "four five six seven" + " ".Red() + " ".White() + " ".Blue() + "eight";
var wrapped = ColumnWrapper.WrapValue(value, c, 20);
var result = FormatResult(value, wrapped, 20);
Console.WriteLine(result);
Approvals.Verify(result);
}
public void ColourInstructionsForLastWordAreIncluded()
{
var c = new ColumnFormat("h", typeof (string));
var value = "four five six seven " + "eight".Red();
var wrapped = ColumnWrapper.WrapValue(value, c, 20);
var result = FormatResult(value, wrapped, 20);
Console.WriteLine(result);
Approvals.Verify(result);
}
public void DefaultColumnRequiresWidthCalculatedFromData()
{
//Arrange
var format = new ColumnFormat("test", typeof(int));
//Act
var result = format.DetermineWidthFromData();
//Assert
Assert.That(result, Is.True);
}
public void FixedWidthColumnDoesNotRequireWidthCalculation()
{
//Arrange
var format = new ColumnFormat("test", typeof(int));
//Act
format.FixedWidth = 6;
var result = format.DetermineWidthFromData();
//Assert
Assert.That(result, Is.False);
}
private static Tuple<int, int> MakeProportionalWidth(int availableWidth, double totalProportions, ColumnFormat format)
{
var proportionalWidth = (availableWidth/totalProportions)*format.ProportionalWidth;
var intWidth = (int)Math.Floor(proportionalWidth);
var excessWidth = 0;
if (intWidth < format.MinWidth)
{
excessWidth = format.MinWidth - intWidth;
intWidth = format.MinWidth;
}
if (format.MaxWidth > 0 && intWidth > format.MaxWidth)
{
intWidth = format.MaxWidth;
excessWidth = 0;
}
return Tuple.Create(intWidth == 0 ? 1 : intWidth, excessWidth);
}
public static string Format(ColumnFormat format, object value)
{
if (value == null) return string.Empty;
var type = value.GetType();
if (format.FormatTemplate != null && IsFormattable(type))
return ApplyFormatTemplate(format.FormatTemplate, value);
if (IsFloatingPoint(type))
{
var formatString = format.DecimalPlaces > 0 ? "0." + new string('0', format.DecimalPlaces) : "0";
if (type == typeof(decimal))
return ((decimal)value).ToString(formatString);
if (type == typeof(float))
return ((float)value).ToString(formatString);
return ((double)value).ToString(formatString);
}
#if TARGET_FRAMEWORK_4
if (value is DateTime && Thread.CurrentThread.CurrentCulture.IetfLanguageTag == "en-GB")
return ((DateTime)value).ToString().TrimEnd(); //patch up faulty date time string format
#endif
return value.ToString();
}
public void SingleLineDataAddsNoLineBreaks()
{
var c = new ColumnFormat("h", typeof (string));
const string value = "One two three.";
var addedBreaks = ColumnWrapper.CountWordwrapLineBreaks(value, c, 20);
Console.WriteLine(string.Join("\r\n", ColumnWrapper.WrapValue(value, c, 20)));
Assert.That(addedBreaks, Is.EqualTo(0));
}
public void TrailingSpacesArePreserved()
{
var c = new ColumnFormat("h", typeof(string));
const string value = "One two three. ";
var wrapped = ColumnWrapper.WrapValue(value, c, 20);
var result = FormatResult(value, wrapped, 20);
Console.WriteLine(result);
Approvals.Verify(result);
}
private static string[] MakeHeading(ColumnFormat format, int columnWidth, int tabLength, int firstLineHangingIndent)
{
var firstLine = string.Format("{0}: ", format.Heading);
return ColumnWrapper.WrapValue(firstLine, new ColumnFormat(null, typeof(string)), columnWidth, tabLength,
firstLineHangingIndent);
}
public void TrailingSpacesDoNotCauseAdditionalLineBreaks()
{
var c = new ColumnFormat("h", typeof (string));
const string value = "One two three four\t\t\t\t\t\t\t\t five\tsix seven eight nine ten eleven.";
var addedBreaks = ColumnWrapper.CountWordwrapLineBreaks(value, c, 20);
Console.WriteLine("----+----|----+----|");
Console.WriteLine(string.Join("\r\n", ColumnWrapper.WrapValue(value, c, 20)));
Assert.That(addedBreaks, Is.EqualTo(3));
}
public void WordsLongerThanOneLineAreBroken()
{
var c = new ColumnFormat("h", typeof (string));
const string value = "One two three four fivesixseveneightnineteneleven.";
var wrapped = ColumnWrapper.WrapValue(value, c, 20);
var result = FormatResult(value, wrapped, 20);
Console.WriteLine(result);
Approvals.Verify(result);
}
public void WrapAndMeasureWordsCanWorkWithSplitData()
{
//Arrange
var c = new ColumnFormat("h", typeof(string));
const string value = "One two three four five six seven eight nine ten eleven.";
var words = WordSplitter.SplitToList(value, 4);
//Act
int wrappedLines;
var wrapped = ColumnWrapper.WrapAndMeasureWords(words, c, 20, 0, out wrappedLines);
//Assert
var result = FormatResult(value, wrapped, 20)
+ Environment.NewLine
+ string.Format("Added line breaks = {0}", wrappedLines);
Console.WriteLine(result);
Approvals.Verify(result);
}
public void DefaultFormatReturnsExpectedWidth()
{
var format = new ColumnFormat("A", typeof (TimeSpan));
Assert.That(TimeSpanWidthCalculator.Calculate(format), Is.EqualTo(_testValue.ToString().Length));
}
public void DecimalValuesAreDisplayedToTwoDpByDefault()
{
var format = new ColumnFormat("decimal", type: typeof(Decimal));
Assert.That(ValueFormatter.Format(format, 1.456m), Is.EqualTo("1.46"));
}
public void NullIsFormattedAsEmptyString()
{
var format = new ColumnFormat("double", type: typeof(float));
Assert.That(ValueFormatter.Format(format, null), Is.EqualTo(string.Empty));
}
public void TemplatedFormatReturnsExpectedWidth()
{
const string template = "yyyy-MM-dd";
var format = new ColumnFormat("A", typeof (DateTime), format: template);
Assert.That(DateTimeWidthCalculator.Calculate(format), Is.EqualTo(DateTime.Now.ToString(template).Length));
}
public void DefaultFormatReturnsExpectedWidth()
{
var format = new ColumnFormat("A", typeof (DateTime));
Assert.That(DateTimeWidthCalculator.Calculate(format), Is.EqualTo(DateTime.Now.ToString().TrimEnd().Length));
}
public void MaxLineBreaksIsCalculated()
{
var columnFormat = new ColumnFormat("", typeof(string));
var sizer = new ColumnSizer(typeof(string), columnFormat);
sizer.ColumnValue("XXXX XXXX XXXX XX XXX");
sizer.ColumnValue("YYYYYY YYYYY YY YYY YY YYYY YY Y");
var sb = new StringBuilder();
sb.AppendLine("Test values:");
sb.AppendLine(sizer.GetSizeValue(0).TextValue);
sb.AppendLine(sizer.GetSizeValue(1).TextValue);
sb.AppendLine("Max Linebreaks:");
for (var width = 15; width > 0; --width)
{
Console.WriteLine(width);
sb.AppendLine();
sb.AppendFormat("Width = {0}, line breaks = {1}", width, sizer.GetMaxLineBreaks(width));
sb.AppendLine();
sb.AppendLine(RulerFormatter.MakeRuler(width));
foreach (var line in ColumnWrapper.WrapValue(sizer.GetSizeValue(1), columnFormat, width))
{
sb.AppendLine(line);
}
}
Console.WriteLine(sb.ToString());
Approvals.Verify(sb.ToString());
}
internal PropertyColumnFormat(PropertyInfo property, ColumnFormat format)
{
Property = property;
Format = format;
}
public void FloatValuesAreDisplayedToTwoDpByDefault()
{
var format = new ColumnFormat("float", type: typeof(float));
Assert.That(ValueFormatter.Format(format, 1.456F), Is.EqualTo("1.46"));
}
public void TemplatedFormatReturnsExpectedWidth()
{
const string template = @"hh\:mm\:ss";
var format = new ColumnFormat("A", typeof (TimeSpan), format: template);
Assert.That(TimeSpanWidthCalculator.Calculate(format), Is.EqualTo(_testValue.ToString(template).Length));
}
public void FirstLineIndentShortensFirstLine()
{
var c = new ColumnFormat("h", typeof(string));
const string value = "One two three four five six seven eight nine ten eleven.";
var wrapped = ColumnWrapper.WrapValue(value, c, 20, firstLineHangingIndent: 10);
var result = FormatResult(value, wrapped, 20);
Console.WriteLine(result);
Approvals.Verify(result);
}
