TextWrapper.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
using CommandLine.Infrastructure;
 
namespace CommandLine.Text
{
    public class TextWrapper
    {
        private string[] lines;
 
        public TextWrapper(string input)
        {
            //start by splitting at newlines and then reinserting the newline as a separate word
            //Note that on the input side, we can't assume the line-break style at run time so we have to
            //be able to handle both.  We can't use Environment.NewLine because that changes at
            //_runtime_ and may not match the line-break style that was compiled in
            lines = input
                    .Replace("\r", "")
                    .Split(new[] { '\n' },
                           StringSplitOptions.None
                          );
        }
 
        public TextWrapper WordWrap(int columnWidth)
        {
            //ensure we always use at least 1 column even if the client has told us there's no space available
            columnWidth = Math.Max(1, columnWidth);
 
            lines = lines
                    .SelectMany(line => WordWrapLine(line, columnWidth))
                    .ToArray();
 
            return this;
        }
 
        public TextWrapper Indent(int numberOfSpaces)
        {
            lines = lines
                    .Select(line => numberOfSpaces.Spaces() + line)
                    .ToArray();
 
            return this;
        }
 
        public string ToText()
        {
            //return the whole thing as a single string
            return string.Join(Environment.NewLine, lines);
        }
 
        public static string WrapAndIndentText(string input, int indentLevel, int columnWidth)
        {
            return new TextWrapper(input)
                   .WordWrap(columnWidth)
                   .Indent(indentLevel)
                   .ToText();
        }
 
 
        private string[] WordWrapLine(string line, int columnWidth)
        {
            //create a list of individual lines generated from the supplied line
 
            //When handling sub-indentation we must always reserve at least one column for text!
            string unindentedLine = line.TrimStart();
            int currentIndentLevel = Math.Min(line.Length - unindentedLine.Length, columnWidth - 1);
            columnWidth -= currentIndentLevel;
 
            return unindentedLine.Split(' ')
                                 .Aggregate(new List<StringBuilder>(),
                                            (lineList, word) =>
                                                AddWordToLastLineOrCreateNewLineIfNecessary(lineList, word, columnWidth)
                                           )
                                 .Select(builder => currentIndentLevel.Spaces() +
                                                    builder.ToString()
                                                           .TrimEnd()
                                        )
                                 .ToArray();
        }
 
        private static List<StringBuilder> AddWordToLastLineOrCreateNewLineIfNecessary(
            List<StringBuilder> lines,
            string word,
            int columnWidth)
        {
            //The current indentation level is based on the previous line but we need to be careful
            string previousLine = lines.LastOrDefault()
                                       ?.ToString() ??
                                  string.Empty;
 
            bool wouldWrap = !lines.Any() || (word.Length > 0 && previousLine.Length + word.Length > columnWidth);
 
            if (!wouldWrap)
            {
                //The usual case is we just append the 'word' and a space to the current line
                //Note that trailing spaces will get removed later when we turn the line list 
                //into a single string
                lines.Last()
                     .Append(word + ' ');
            }
            else
            {
                //The 'while' here is to take account of the possibility of someone providing a word
                //which just can't fit in the current column.  In that case we just split it at the 
                //column end.
                //That's a rare case though - most of the time we'll succeed in a single pass without
                //having to split
                //Note that we always do at least one pass even if the 'word' is empty in order to 
                //honour sub-indentation and extra spaces within strings
                do
                {
                    int availableCharacters = Math.Min(columnWidth, word.Length);
                    string segmentToAdd = LeftString(word, availableCharacters) + ' ';
                    lines.Add(new StringBuilder(segmentToAdd));
                    word = RightString(word, availableCharacters);
                }
                while (word.Length > 0);
            }
 
            return lines;
        }
 
 
        private static string RightString(string str, int n)
        {
            return n >= str.Length || str.Length == 0
                       ? string.Empty
                       : str.Substring(n);
        }
 
        private static string LeftString(string str, int n)
        {
            return n >= str.Length || str.Length == 0
                       ? str
                       : str.Substring(0, n);
        }
    }
}