7473956714

Committed 10 Jan 2024 11:03AM UTC coverage: 35.959% (+6.3%) from 29.667%

Build # 7473956714

Build Type

push

github

Committed by

MorganKryze

Commit Message

✅ (window) achieve 99% coverage on window, left unreachable edge cases

Run Details

518 of 1490 branches covered (0.0%)

Branch coverage included in aggregate %.

4 of 4 new or added lines in 1 file covered. (100.0%)

5 existing lines in 2 files now uncovered.

929 of 2534 relevant lines covered (36.66%)

123.54 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

49.59

/src/ConsoleAppVisuals/elements/TableView.cs

/*
    MIT License 2023 MorganKryze
    For full license information, please visit: https://github.com/MorganKryze/ConsoleAppVisuals/blob/main/LICENSE
*/
namespace ConsoleAppVisuals;

/// <summary>
/// The <see cref="Table{T}"/> class that contains the methods to create a table and display it.
/// </summary>
public class TableView<T> : Element
{
    #region Fields: title, headers, lines, display array, rounded corners
    private string? _title;
    private List<string>? _rawHeaders;
    private List<List<T>>? _rawLines;
    private string[]? _displayArray;
    private bool _roundedCorners = true;
    private readonly int _line;
    private readonly Placement _placement;

    #endregion

    #region Properties: get headers, get lines
    /// <summary>
    /// This property returns the headers of the table.
    /// </summary>
    public List<string>? GetRawHeaders => _rawHeaders;

    /// <summary>
    /// This property returns the lines of the table.
    /// </summary>
    public List<List<T>>? GetRawLines => _rawLines;

    /// <summary>
    /// This property returns the title of the table.
    /// </summary>
    public override Placement Placement => _placement;

    /// <summary>
    /// This property returns the line to display the table on.
    /// </summary>
    public override int Line => _line;

    /// <summary>
    /// This property returns the height of the table.
    /// </summary>
    public override int Height => _displayArray?.Length ?? 0;

    /// <summary>
    /// This property returns the width of the table.
    /// </summary>
    public override int Width => _displayArray?.Max(x => x.Length) ?? 0;

    /// <summary>
    /// This property returns the maximum number of this element that can be displayed on the console.
    /// </summary>
    public override int MaxNumberOfThisElement { get; } = 9;

    #endregion

    #region Constructor
    /// <summary>
    /// The <see cref="Table{T}"/> natural constructor.
    /// </summary>
    /// <param name="title">The title of the table.</param>
    /// <param name="lines">The lines of the table.</param>
    /// <param name="headers">The headers of the table.</param>
    /// <param name="placement">The placement of the table.</param>
    /// <param name="line">The line to display the table on.</param>
    /// <exception cref="ArgumentException">Is thrown when the number of columns in the table is not consistent with itself or with the headers.</exception>
    /// <exception cref="NullReferenceException">Is thrown when no body lines were provided.</exception>
    /// <remarks>Refer to the example project to understand how to implement it available at https://github.com/MorganKryze/ConsoleAppVisuals/blob/main/example/Program.cs </remarks>
    public TableView(
        string? title = null,
        List<string>? headers = null,
        List<List<T>>? lines = null,
        Placement placement = Placement.TopCenter,
        int? line = null
    )
    {
        _title = title;
        _rawHeaders = headers;
        _rawLines = lines;
        _placement = placement;
        _line = Window.CheckLine(line) ?? Window.GetLineAvailable(placement);
        if (CompatibilityCheck())
        {
            BuildTable();
        }
    }
    #endregion

    #region Check Methods
    private bool CompatibilityCheck()
    {
        if (_rawHeaders is null)
        {
            return CheckRawLines();
        }
        else if (_rawLines is null)
        {
            return true;
        }
        else
        {
            return CheckRawHeadersAndLines();
        }
    }

    private bool CheckRawLines()
    {
        if (_rawLines is null || _rawLines.Count == 0)
        {
            return false;
        }

        for (int i = 0; i < _rawLines.Count; i++)
        {
            if (_rawLines[i].Count != _rawLines[0].Count)
            {
                throw new ArgumentException(
                    "The number of columns in the table is not consistent."
                );
            }
        }

        return true;
    }

    private bool CheckRawHeadersAndLines()
    {
        if (_rawLines is null || _rawLines.Count == 0)
        {
            return false;
        }

        if (_rawLines.Count > 0)
        {
            for (int i = 0; i < _rawLines.Count; i++)
            {
                if (_rawLines[i].Count != _rawHeaders?.Count)
                {
                    throw new ArgumentException(
                        "The number of columns in the table is not consistent(Headers or Lines)."
                    );
                }
            }

            return true;
        }

        return false;
    }
    #endregion

    #region Build Methods
    private void BuildTable()
    {
        if (_rawHeaders is null)
        {
            if (_rawLines is not null)
            {
                BuildLines();
            }
        }
        else
        {
            if (_rawLines is null)
            {
                BuildHeaders();
            }
            else
            {
                BuildHeadersAndLines();
            }
        }
    }

    private void BuildHeadersAndLines()
    {
        if (_rawHeaders is not null && _rawLines is not null)
        {
            var stringList = new List<string>();
            var localMax = new int[_rawHeaders.Count];
            for (int i = 0; i < _rawHeaders.Count; i++)
            {
                if (_rawHeaders[i]?.Length > localMax[i])
                {
                    localMax[i] = _rawHeaders[i]?.Length ?? 0;
                }
            }

            for (int i = 0; i < _rawLines.Count; i++)
            {
                for (int j = 0; j < _rawLines[i].Count; j++)
                {
                    if (_rawLines[i][j]?.ToString()?.Length > localMax[j])
                    {
                        localMax[j] = _rawLines[i][j]?.ToString()?.Length ?? 0;
                    }
                }
            }

            StringBuilder headerBuilder = new("│ ");
            for (int i = 0; i < _rawHeaders.Count; i++)
            {
                headerBuilder.Append(_rawHeaders[i]?.PadRight(localMax[i]) ?? "");
                if (i != _rawHeaders.Count - 1)
                {
                    headerBuilder.Append(" │ ");
                }
                else
                {
                    headerBuilder.Append(" │");
                }
            }
            stringList.Add(headerBuilder.ToString());

            StringBuilder upperBorderBuilder = new(GetCorners[0].ToString());
            for (int i = 0; i < _rawHeaders.Count; i++)
            {
                upperBorderBuilder.Append(new string('─', localMax[i] + 2));
                upperBorderBuilder.Append(
                    (i != _rawHeaders.Count - 1) ? "┬" : GetCorners[1].ToString()
                );
            }
            stringList.Insert(0, upperBorderBuilder.ToString());

            StringBuilder intermediateBorderBuilder = new("├");
            for (int i = 0; i < _rawHeaders.Count; i++)
            {
                intermediateBorderBuilder.Append(new string('─', localMax[i] + 2));
                intermediateBorderBuilder.Append((i != _rawHeaders.Count - 1) ? "┼" : "┤");
            }
            stringList.Add(intermediateBorderBuilder.ToString());

            for (int i = 0; i < _rawLines.Count; i++)
            {
                StringBuilder lineBuilder = new("│ ");
                for (int j = 0; j < _rawLines[i].Count; j++)
                {
                    lineBuilder.Append(_rawLines[i][j]?.ToString()?.PadRight(localMax[j]) ?? "");
                    if (j != _rawLines[i].Count - 1)
                    {
                        lineBuilder.Append(" │ ");
                    }
                    else
                    {
                        lineBuilder.Append(" │");
                    }
                }
                stringList.Add(lineBuilder.ToString());
            }

            StringBuilder lowerBorderBuilder = new(GetCorners[2].ToString());
            for (int i = 0; i < _rawHeaders.Count; i++)
            {
                lowerBorderBuilder.Append(new string('─', localMax[i] + 2));
                lowerBorderBuilder.Append(
                    (i != _rawHeaders.Count - 1) ? "┴" : GetCorners[3].ToString()
                );
            }
            stringList.Add(lowerBorderBuilder.ToString());

            _displayArray = stringList.ToArray();
            BuildTitle();
        }
    }

    private void BuildHeaders()
    {
        if (_rawHeaders is not null)
        {
            var stringList = new List<string>();
            var localMax = new int[_rawHeaders.Count];
            for (int i = 0; i < _rawHeaders.Count; i++)
            {
                if (_rawHeaders[i]?.Length > localMax[i])
                {
                    localMax[i] = _rawHeaders[i]?.Length ?? 0;
                }
            }
            StringBuilder headerBuilder = new("│ ");
            for (int i = 0; i < _rawHeaders.Count; i++)
            {
                headerBuilder.Append(_rawHeaders[i]?.PadRight(localMax[i]) ?? "");
                if (i != _rawHeaders.Count - 1)
                {
                    headerBuilder.Append(" │ ");
                }
                else
                {
                    headerBuilder.Append(" │");
                }
            }
            stringList.Add(headerBuilder.ToString());
            StringBuilder upperBorderBuilder = new(GetCorners[0].ToString());
            for (int i = 0; i < _rawHeaders.Count; i++)
            {
                upperBorderBuilder.Append(new string('─', localMax[i] + 2));
                upperBorderBuilder.Append(
                    (i != _rawHeaders.Count - 1) ? "┬" : GetCorners[1].ToString()
                );
            }
            stringList.Insert(0, upperBorderBuilder.ToString());
            StringBuilder lowerBorderBuilder = new(GetCorners[2].ToString());
            for (int i = 0; i < _rawHeaders.Count; i++)
            {
                lowerBorderBuilder.Append(new string('─', localMax[i] + 2));
                lowerBorderBuilder.Append(
                    (i != _rawHeaders.Count - 1) ? "┴" : GetCorners[3].ToString()
                );
            }
            stringList.Add(lowerBorderBuilder.ToString());
            _displayArray = stringList.ToArray();
            BuildTitle();
        }
    }

    private void BuildLines()
    {
        if (_rawLines is not null)
        {
            var stringList = new List<string>();
            var localMax = new int[_rawLines[0].Count];
            for (int i = 0; i < _rawLines.Count; i++)
            {
                for (int j = 0; j < _rawLines[i].Count; j++)
                {
                    if (_rawLines[i][j]?.ToString()?.Length > localMax[j])
                    {
                        localMax[j] = _rawLines[i][j]?.ToString()?.Length ?? 0;
                    }
                }
            }
            for (int i = 0; i < _rawLines.Count; i++)
            {
                StringBuilder line = new("│ ");
                for (int j = 0; j < _rawLines[i].Count; j++)
                {
                    line.Append(_rawLines[i][j]?.ToString()?.PadRight(localMax[j]) ?? "");
                    if (j != _rawLines[i].Count - 1)
                    {
                        line.Append(" │ ");
                    }
                    else
                    {
                        line.Append(" │");
                    }
                }
                stringList.Add(line.ToString());
            }
            StringBuilder upperBorderBuilder = new(GetCorners[0].ToString());
            for (int i = 0; i < _rawLines.Count; i++)
            {
                upperBorderBuilder.Append(new string('─', localMax[i] + 2));
                upperBorderBuilder.Append(
                    (i != _rawLines.Count - 1) ? "┬" : GetCorners[1].ToString()
                );
            }
            stringList.Insert(0, upperBorderBuilder.ToString());
            StringBuilder lowerBorderBuilder = new(GetCorners[2].ToString());
            for (int i = 0; i < _rawLines.Count; i++)
            {
                lowerBorderBuilder.Append(new string('─', localMax[i] + 2));
                lowerBorderBuilder.Append(
                    (i != _rawLines.Count - 1) ? "┴" : GetCorners[3].ToString()
                );
            }
            stringList.Add(lowerBorderBuilder.ToString());
            _displayArray = stringList.ToArray();
            BuildTitle();
        }
    }

    private void BuildTitle()
    {
        if (_title is not null)
        {
            var len = _displayArray![0].Length;
            var title = _title.ResizeString(len - 4);
            title = $"│ {title} │";
            var upperBorderBuilder = new StringBuilder(GetCorners[0].ToString());
            upperBorderBuilder.Append(new string('─', len - 2));
            upperBorderBuilder.Append(GetCorners[1].ToString());
            var display = _displayArray.ToList();
            display[0] = display[0]
                .Remove(0, 1)
                .Insert(0, "├")
                .Remove(display[1].Length - 1, 1)
                .Insert(display[1].Length - 1, "┤");
            display.Insert(0, title);
            display.Insert(0, upperBorderBuilder.ToString());
            _displayArray = display.ToArray();
        }
    }
    #endregion

    #region Properties: get corners, count
    private string GetCorners => _roundedCorners ? "╭╮╰╯" : "┌┐└┘";

    /// <summary>
    /// This property returns the number of lines in the table.
    /// </summary>
    public int Count => _rawLines?.Count ?? 0;

    #endregion

    #region Methods: Get, Add, Update, Remove, Clear
    /// <summary>
    /// This method adds headers to the table.
    /// </summary>
    /// <param name="headers">The headers to add.</param>
    public void AddHeaders(List<string> headers)
    {
        _rawHeaders = headers;
        if (CompatibilityCheck())
        {
            BuildTable();
        }
        else
        {
            _rawHeaders = null;
        }
    }

    /// <summary>
    /// This method updates the headers of the table.
    /// </summary>
    /// <param name="headers">The headers to update.</param>
    public void UpdateHeaders(List<string> headers)
    {
        AddHeaders(headers);
    }

    /// <summary>
    /// This method adds a title to the table.
    /// </summary>
    /// <param name="title">The title to add.</param>
    public void AddTitle(string title)
    {
        _title = title;
        BuildTable();
    }

    /// <summary>
    /// This method updates the title of the table.
    /// </summary>
    /// <param name="title">The title to update.</param>
    public void UpdateTitle(string title)
    {
        AddTitle(title);
    }

    /// <summary>
    /// Toggles the rounded corners of the table.
    /// </summary>
    /// <remarks>Refer to the example project to understand how to implement it available at https://github.com/MorganKryze/ConsoleAppVisuals/blob/main/example/Program.cs </remarks>
    public void SetRoundedCorners(bool rounded = true)
    {
        _roundedCorners = rounded;
        BuildTable();
    }

    /// <summary>
    /// This property returns the specified line in the table.
    /// </summary>
    /// <param name="index">The index of the line to return.</param>
    /// <returns>The line at the specified index.</returns>
    /// <exception cref="ArgumentOutOfRangeException">Is thrown when the index is out of range.</exception>
    /// <remarks>Refer to the example project to understand how to implement it available at https://github.com/MorganKryze/ConsoleAppVisuals/blob/main/example/Program.cs </remarks>
    public List<T> GetLine(int index)
    {
        if (index < 0 || index >= _rawLines?.Count)
        {
            throw new ArgumentOutOfRangeException(nameof(index), "The index is out of range.");
        }
        return _rawLines![index];
    }

    /// <summary>
    /// This method is used to get all the elements from a column given its index.
    /// </summary>
    /// <param name="index">The index of the column.</param>
    /// <returns>The elements of the column.</returns>
    /// <exception cref="ArgumentOutOfRangeException">Is thrown when the index is out of range.</exception>
    public List<T>? GetColumnData(int index)
    {
        if (_rawLines is null)
        {
            return null;
        }

        if (index < 0 || index >= _rawLines[0].Count)
        {
            throw new ArgumentOutOfRangeException(nameof(index), "Invalid column index.");
        }

        List<T>? list = new();
        for (int i = 0; i < _rawLines.Count; i++)
        {
            list.Add(_rawLines[i][index]);
        }
        return list;
    }

    /// <summary>
    /// This method is used to get all the elements from a column given its header.
    /// </summary>
    /// <param name="header">The header of the column.</param>
    /// <returns>The elements of the column.</returns>
    /// <exception cref="InvalidOperationException">Is thrown when the table is empty.</exception>
    /// <exception cref="ArgumentOutOfRangeException">Is thrown when the header is invalid.</exception>
    public List<T>? GetColumnData(string header)
    {
        if (_rawHeaders is null)
        {
            throw new InvalidOperationException("The headers are null.");
        }
        else if (_rawLines is null)
        {
            return null;
        }
        if (!_rawHeaders.Contains(header))
        {
            throw new ArgumentOutOfRangeException(nameof(header), "Invalid column header.");
        }

        return GetColumnData(_rawHeaders.IndexOf(header));
    }

    /// <summary>
    /// This method adds a line to the table.
    /// </summary>
    /// <param name="line">The line to add.</param>
    /// <exception cref="ArgumentException">Is thrown when the number of columns in the table is not consistent with itself or with the headers.</exception>
    /// <remarks>Refer to the example project to understand how to implement it available at https://github.com/MorganKryze/ConsoleAppVisuals/blob/main/example/Program.cs </remarks>
    public void AddLine(List<T> line)
    {
        if (_rawLines?.Count > 0 && line.Count != _rawLines[0].Count)
        {
            throw new ArgumentException(
                "The number of columns in the table is not consistent with other lines."
            );
        }
        if (_rawHeaders is not null && line.Count != _rawHeaders.Count)
        {
            throw new ArgumentException(
                "The number of columns in the table is not consistent with the headers."
            );
        }
        _rawLines ??= new List<List<T>>();
        _rawLines.Add(line);
        BuildTable();
    }

    /// <summary>
    /// This method removes a line from the table.
    /// </summary>
    /// <param name="index">The index of the line to remove.</param>
    /// <exception cref="ArgumentOutOfRangeException">Is thrown when the index is out of range.</exception>
    /// <remarks>Refer to the example project to understand how to implement it available at https://github.com/MorganKryze/ConsoleAppVisuals/blob/main/example/Program.cs </remarks>
    public void RemoveLine(int index)
    {
        if (_rawLines?.Count > 0 && (index < 0 || index >= _rawLines.Count))
        {
            throw new ArgumentOutOfRangeException(nameof(index), "The index is out of range.");
        }

        _rawLines?.RemoveAt(index);
        BuildTable();
    }

    /// <summary>
    /// This method updates a line in the table.
    /// </summary>
    /// <param name="index">The index of the line to update.</param>
    /// <param name="line">The new line.</param>
    /// <exception cref="ArgumentOutOfRangeException">Is thrown when the index is out of range.</exception>
    /// <exception cref="ArgumentException">Is thrown when the number of columns in the table is not consistent with itself or with the headers.</exception>
    /// <remarks>Refer to the example project to understand how to implement it available at https://github.com/MorganKryze/ConsoleAppVisuals/blob/main/example/Program.cs </remarks>
    public void UpdateLine(int index, List<T> line)
    {
        if (_rawLines?.Count > 0)
        {
            if (index < 0 || index >= _rawLines.Count)
            {
                throw new ArgumentOutOfRangeException(nameof(index), "The index is out of range.");
            }

            if (line.Count != _rawHeaders?.Count)
            {
                throw new ArgumentException(
                    "The number of columns in the table is not consistent."
                );
            }
        }
        _rawLines![index] = line;
        BuildTable();
    }

    /// <summary>
    /// This method clears the headers of the table.
    /// </summary>
    public void ClearHeaders()
    {
        _rawHeaders = null;
        BuildTable();
    }

    /// <summary>
    /// This method clears the lines of the table.
    /// </summary>
    public void ClearLines()
    {
        _rawLines = null;
        BuildTable();
    }

    /// <summary>
    /// This method clears the table.
    /// </summary>
    public void Reset()
    {
        _title = null;
        _rawHeaders?.Clear();
        _rawLines?.Clear();
        _displayArray = null;
    }
    #endregion

    #region Display Methods
    /// <summary>
    /// This method displays the table without interaction.
    /// </summary>
    protected override void RenderElementActions()
    {
        string[] array = new string[_displayArray!.Length];
        for (int j = 0; j < _displayArray.Length; j++)
        {
            array[j] = _displayArray[j];
            Core.WritePositionedString(
                array[j],
                _placement.ToTextAlignment(),
                false,
                _line + j
            );
        }
    }
    #endregion
}

1	/*
2	MIT License 2023 MorganKryze
3	For full license information, please visit: https://github.com/MorganKryze/ConsoleAppVisuals/blob/main/LICENSE
4	*/
5	namespace ConsoleAppVisuals;
6
7	/// <summary>
8	/// The <see cref="Table{T}"/> class that contains the methods to create a table and display it.
9	/// </summary>
10	public class TableView<T> : Element
11	{
12	#region Fields: title, headers, lines, display array, rounded corners
13	private string? _title;
14	private List<string>? _rawHeaders;
15	private List<List<T>>? _rawLines;
16	private string[]? _displayArray;
17	private bool _roundedCorners = true;	42✔
18	private readonly int _line;
19	private readonly Placement _placement;
20
21	#endregion
22
23	#region Properties: get headers, get lines
24	/// <summary>
25	/// This property returns the headers of the table.
26	/// </summary>
27	public List<string>? GetRawHeaders => _rawHeaders;	×
28
29	/// <summary>
30	/// This property returns the lines of the table.
31	/// </summary>
32	public List<List<T>>? GetRawLines => _rawLines;	×
33
34	/// <summary>
35	/// This property returns the title of the table.
36	/// </summary>
37	public override Placement Placement => _placement;	84✔
38
39	/// <summary>
40	/// This property returns the line to display the table on.
41	/// </summary>
42	public override int Line => _line;	30✔
43
44	/// <summary>
45	/// This property returns the height of the table.
46	/// </summary>
47	public override int Height => _displayArray?.Length ?? 0;	39!
48
49	/// <summary>
50	/// This property returns the width of the table.
51	/// </summary>
52	public override int Width => _displayArray?.Max(x => x.Length) ?? 0;	336!
53
54	/// <summary>
55	/// This property returns the maximum number of this element that can be displayed on the console.
56	/// </summary>
57	public override int MaxNumberOfThisElement { get; } = 9;	108✔
58
59	#endregion
60
61	#region Constructor
62	/// <summary>
63	/// The <see cref="Table{T}"/> natural constructor.
64	/// </summary>
65	/// <param name="title">The title of the table.</param>
66	/// <param name="lines">The lines of the table.</param>
67	/// <param name="headers">The headers of the table.</param>
68	/// <param name="placement">The placement of the table.</param>
69	/// <param name="line">The line to display the table on.</param>
70	/// <exception cref="ArgumentException">Is thrown when the number of columns in the table is not consistent with itself or with the headers.</exception>
71	/// <exception cref="NullReferenceException">Is thrown when no body lines were provided.</exception>
72	/// <remarks>Refer to the example project to understand how to implement it available at https://github.com/MorganKryze/ConsoleAppVisuals/blob/main/example/Program.cs </remarks>
73	public TableView(	42✔
74	string? title = null,	42✔
75	List<string>? headers = null,	42✔
76	List<List<T>>? lines = null,	42✔
77	Placement placement = Placement.TopCenter,	42✔
78	int? line = null	42✔
79	)	42✔
80	{
81	_title = title;	42✔
82	_rawHeaders = headers;	42✔
83	_rawLines = lines;	42✔
84	_placement = placement;	42✔
85	_line = Window.CheckLine(line) ?? Window.GetLineAvailable(placement);	42!
86	if (CompatibilityCheck())	42✔
87	{
88	BuildTable();	42✔
89	}
90	}	42✔
91	#endregion
92
93	#region Check Methods
94	private bool CompatibilityCheck()
95	{
96	if (_rawHeaders is null)	42!
97	{
UNCOV 98	return CheckRawLines();	×
99	}
100	else if (_rawLines is null)	42!
101	{
102	return true;	42✔
103	}
104	else
105	{
106	return CheckRawHeadersAndLines();	×
107	}
108	}
109
110	private bool CheckRawLines()
111	{
UNCOV 112	if (_rawLines is null \|\| _rawLines.Count == 0)	×
113	{
UNCOV 114	return false;	×
115	}
116
117	for (int i = 0; i < _rawLines.Count; i++)	×
118	{
119	if (_rawLines[i].Count != _rawLines[0].Count)	×
120	{
121	throw new ArgumentException(	×
122	"The number of columns in the table is not consistent."	×
123	);	×
124	}
125	}
126
127	return true;	×
128	}
129
130	private bool CheckRawHeadersAndLines()
131	{
132	if (_rawLines is null \|\| _rawLines.Count == 0)	×
133	{
134	return false;	×
135	}
136
137	if (_rawLines.Count > 0)	×
138	{
139	for (int i = 0; i < _rawLines.Count; i++)	×
140	{
141	if (_rawLines[i].Count != _rawHeaders?.Count)	×
142	{
143	throw new ArgumentException(	×
144	"The number of columns in the table is not consistent(Headers or Lines)."	×
145	);	×
146	}
147	}
148
149	return true;	×
150	}
151
152	return false;	×
153	}
154	#endregion
155
156	#region Build Methods
157	private void BuildTable()
158	{
159	if (_rawHeaders is null)	312!
160	{
161	if (_rawLines is not null)	×
162	{
163	BuildLines();	×
164	}
165	}
166	else
167	{
168	if (_rawLines is null)	312✔
169	{
170	BuildHeaders();	42✔
171	}
172	else
173	{
174	BuildHeadersAndLines();	270✔
175	}
176	}
177	}	270✔
178
179	private void BuildHeadersAndLines()
180	{
181	if (_rawHeaders is not null && _rawLines is not null)	270✔
182	{
183	var stringList = new List<string>();	270✔
184	var localMax = new int[_rawHeaders.Count];	270✔
185	for (int i = 0; i < _rawHeaders.Count; i++)	2,520✔
186	{
187	if (_rawHeaders[i]?.Length > localMax[i])	990!
188	{
189	localMax[i] = _rawHeaders[i]?.Length ?? 0;	990!
190	}
191	}
192
193	for (int i = 0; i < _rawLines.Count; i++)	3,660✔
194	{
195	for (int j = 0; j < _rawLines[i].Count; j++)	13,056✔
196	{
197	if (_rawLines[i][j]?.ToString()?.Length > localMax[j])	4,968!
198	{
199	localMax[j] = _rawLines[i][j]?.ToString()?.Length ?? 0;	828!
200	}
201	}
202	}
203
204	StringBuilder headerBuilder = new("│ ");	270✔
205	for (int i = 0; i < _rawHeaders.Count; i++)	2,520✔
206	{
207	headerBuilder.Append(_rawHeaders[i]?.PadRight(localMax[i]) ?? "");	990!
208	if (i != _rawHeaders.Count - 1)	990✔
209	{
210	headerBuilder.Append(" │ ");	720✔
211	}
212	else
213	{
214	headerBuilder.Append(" │");	270✔
215	}
216	}
217	stringList.Add(headerBuilder.ToString());	270✔
218
219	StringBuilder upperBorderBuilder = new(GetCorners[0].ToString());	270✔
220	for (int i = 0; i < _rawHeaders.Count; i++)	2,520✔
221	{
222	upperBorderBuilder.Append(new string('─', localMax[i] + 2));	990✔
223	upperBorderBuilder.Append(	990✔
224	(i != _rawHeaders.Count - 1) ? "┬" : GetCorners[1].ToString()	990✔
225	);	990✔
226	}
227	stringList.Insert(0, upperBorderBuilder.ToString());	270✔
228
229	StringBuilder intermediateBorderBuilder = new("├");	270✔
230	for (int i = 0; i < _rawHeaders.Count; i++)	2,520✔
231	{
232	intermediateBorderBuilder.Append(new string('─', localMax[i] + 2));	990✔
233	intermediateBorderBuilder.Append((i != _rawHeaders.Count - 1) ? "┼" : "┤");	990✔
234	}
235	stringList.Add(intermediateBorderBuilder.ToString());	270✔
236
237	for (int i = 0; i < _rawLines.Count; i++)	3,660✔
238	{
239	StringBuilder lineBuilder = new("│ ");	1,560✔
240	for (int j = 0; j < _rawLines[i].Count; j++)	13,056✔
241	{
242	lineBuilder.Append(_rawLines[i][j]?.ToString()?.PadRight(localMax[j]) ?? "");	4,968!
243	if (j != _rawLines[i].Count - 1)	4,968✔
244	{
245	lineBuilder.Append(" │ ");	3,408✔
246	}
247	else
248	{
249	lineBuilder.Append(" │");	1,560✔
250	}
251	}
252	stringList.Add(lineBuilder.ToString());	1,560✔
253	}
254
255	StringBuilder lowerBorderBuilder = new(GetCorners[2].ToString());	270✔
256	for (int i = 0; i < _rawHeaders.Count; i++)	2,520✔
257	{
258	lowerBorderBuilder.Append(new string('─', localMax[i] + 2));	990✔
259	lowerBorderBuilder.Append(	990✔
260	(i != _rawHeaders.Count - 1) ? "┴" : GetCorners[3].ToString()	990✔
261	);	990✔
262	}
263	stringList.Add(lowerBorderBuilder.ToString());	270✔
264
265	_displayArray = stringList.ToArray();	270✔
266	BuildTitle();	270✔
267	}
268	}	270✔
269
270	private void BuildHeaders()
271	{
272	if (_rawHeaders is not null)	42✔
273	{
274	var stringList = new List<string>();	42✔
275	var localMax = new int[_rawHeaders.Count];	42✔
276	for (int i = 0; i < _rawHeaders.Count; i++)	552✔
277	{
278	if (_rawHeaders[i]?.Length > localMax[i])	234!
279	{
280	localMax[i] = _rawHeaders[i]?.Length ?? 0;	234!
281	}
282	}
283	StringBuilder headerBuilder = new("│ ");	42✔
284	for (int i = 0; i < _rawHeaders.Count; i++)	552✔
285	{
286	headerBuilder.Append(_rawHeaders[i]?.PadRight(localMax[i]) ?? "");	234!
287	if (i != _rawHeaders.Count - 1)	234✔
288	{
289	headerBuilder.Append(" │ ");	192✔
290	}
291	else
292	{
293	headerBuilder.Append(" │");	42✔
294	}
295	}
296	stringList.Add(headerBuilder.ToString());	42✔
297	StringBuilder upperBorderBuilder = new(GetCorners[0].ToString());	42✔
298	for (int i = 0; i < _rawHeaders.Count; i++)	552✔
299	{
300	upperBorderBuilder.Append(new string('─', localMax[i] + 2));	234✔
301	upperBorderBuilder.Append(	234✔
302	(i != _rawHeaders.Count - 1) ? "┬" : GetCorners[1].ToString()	234✔
303	);	234✔
304	}
305	stringList.Insert(0, upperBorderBuilder.ToString());	42✔
306	StringBuilder lowerBorderBuilder = new(GetCorners[2].ToString());	42✔
307	for (int i = 0; i < _rawHeaders.Count; i++)	552✔
308	{
309	lowerBorderBuilder.Append(new string('─', localMax[i] + 2));	234✔
310	lowerBorderBuilder.Append(	234✔
311	(i != _rawHeaders.Count - 1) ? "┴" : GetCorners[3].ToString()	234✔
312	);	234✔
313	}
314	stringList.Add(lowerBorderBuilder.ToString());	42✔
315	_displayArray = stringList.ToArray();	42✔
316	BuildTitle();	42✔
317	}
318	}	42✔
319
320	private void BuildLines()
321	{
322	if (_rawLines is not null)	×
323	{
324	var stringList = new List<string>();	×
325	var localMax = new int[_rawLines[0].Count];	×
326	for (int i = 0; i < _rawLines.Count; i++)	×
327	{
328	for (int j = 0; j < _rawLines[i].Count; j++)	×
329	{
330	if (_rawLines[i][j]?.ToString()?.Length > localMax[j])	×
331	{
332	localMax[j] = _rawLines[i][j]?.ToString()?.Length ?? 0;	×
333	}
334	}
335	}
336	for (int i = 0; i < _rawLines.Count; i++)	×
337	{
338	StringBuilder line = new("│ ");	×
339	for (int j = 0; j < _rawLines[i].Count; j++)	×
340	{
341	line.Append(_rawLines[i][j]?.ToString()?.PadRight(localMax[j]) ?? "");	×
342	if (j != _rawLines[i].Count - 1)	×
343	{
344	line.Append(" │ ");	×
345	}
346	else
347	{
348	line.Append(" │");	×
349	}
350	}
351	stringList.Add(line.ToString());	×
352	}
353	StringBuilder upperBorderBuilder = new(GetCorners[0].ToString());	×
354	for (int i = 0; i < _rawLines.Count; i++)	×
355	{
356	upperBorderBuilder.Append(new string('─', localMax[i] + 2));	×
357	upperBorderBuilder.Append(	×
358	(i != _rawLines.Count - 1) ? "┬" : GetCorners[1].ToString()	×
359	);	×
360	}
361	stringList.Insert(0, upperBorderBuilder.ToString());	×
362	StringBuilder lowerBorderBuilder = new(GetCorners[2].ToString());	×
363	for (int i = 0; i < _rawLines.Count; i++)	×
364	{
365	lowerBorderBuilder.Append(new string('─', localMax[i] + 2));	×
366	lowerBorderBuilder.Append(	×
367	(i != _rawLines.Count - 1) ? "┴" : GetCorners[3].ToString()	×
368	);	×
369	}
370	stringList.Add(lowerBorderBuilder.ToString());	×
371	_displayArray = stringList.ToArray();	×
372	BuildTitle();	×
373	}
374	}	×
375
376	private void BuildTitle()
377	{
378	if (_title is not null)	312✔
379	{
380	var len = _displayArray![0].Length;	312✔
381	var title = _title.ResizeString(len - 4);	312✔
382	title = $"│ {title} │";	312✔
383	var upperBorderBuilder = new StringBuilder(GetCorners[0].ToString());	312✔
384	upperBorderBuilder.Append(new string('─', len - 2));	312✔
385	upperBorderBuilder.Append(GetCorners[1].ToString());	312✔
386	var display = _displayArray.ToList();	312✔
387	display[0] = display[0]	312✔
388	.Remove(0, 1)	312✔
389	.Insert(0, "├")	312✔
390	.Remove(display[1].Length - 1, 1)	312✔
391	.Insert(display[1].Length - 1, "┤");	312✔
392	display.Insert(0, title);	312✔
393	display.Insert(0, upperBorderBuilder.ToString());	312✔
394	_displayArray = display.ToArray();	312✔
395	}
396	}	312✔
397	#endregion
398
399	#region Properties: get corners, count
400	private string GetCorners => _roundedCorners ? "╭╮╰╯" : "┌┐└┘";	1,872!
401
402	/// <summary>
403	/// This property returns the number of lines in the table.
404	/// </summary>
405	public int Count => _rawLines?.Count ?? 0;	×
406
407	#endregion
408
409	#region Methods: Get, Add, Update, Remove, Clear
410	/// <summary>
411	/// This method adds headers to the table.
412	/// </summary>
413	/// <param name="headers">The headers to add.</param>
414	public void AddHeaders(List<string> headers)
415	{
416	_rawHeaders = headers;	×
417	if (CompatibilityCheck())	×
418	{
419	BuildTable();	×
420	}
421	else
422	{
423	_rawHeaders = null;	×
424	}
425	}	×
426
427	/// <summary>
428	/// This method updates the headers of the table.
429	/// </summary>
430	/// <param name="headers">The headers to update.</param>
431	public void UpdateHeaders(List<string> headers)
432	{
433	AddHeaders(headers);	×
434	}	×
435
436	/// <summary>
437	/// This method adds a title to the table.
438	/// </summary>
439	/// <param name="title">The title to add.</param>
440	public void AddTitle(string title)
441	{
442	_title = title;	×
443	BuildTable();	×
444	}	×
445
446	/// <summary>
447	/// This method updates the title of the table.
448	/// </summary>
449	/// <param name="title">The title to update.</param>
450	public void UpdateTitle(string title)
451	{
452	AddTitle(title);	×
453	}	×
454
455	/// <summary>
456	/// Toggles the rounded corners of the table.
457	/// </summary>
458	/// <remarks>Refer to the example project to understand how to implement it available at https://github.com/MorganKryze/ConsoleAppVisuals/blob/main/example/Program.cs </remarks>
459	public void SetRoundedCorners(bool rounded = true)
460	{
461	_roundedCorners = rounded;	×
462	BuildTable();	×
463	}	×
464
465	/// <summary>
466	/// This property returns the specified line in the table.
467	/// </summary>
468	/// <param name="index">The index of the line to return.</param>
469	/// <returns>The line at the specified index.</returns>
470	/// <exception cref="ArgumentOutOfRangeException">Is thrown when the index is out of range.</exception>
471	/// <remarks>Refer to the example project to understand how to implement it available at https://github.com/MorganKryze/ConsoleAppVisuals/blob/main/example/Program.cs </remarks>
472	public List<T> GetLine(int index)
473	{
474	if (index < 0 \|\| index >= _rawLines?.Count)	×
475	{
476	throw new ArgumentOutOfRangeException(nameof(index), "The index is out of range.");	×
477	}
478	return _rawLines![index];	×
479	}
480
481	/// <summary>
482	/// This method is used to get all the elements from a column given its index.
483	/// </summary>
484	/// <param name="index">The index of the column.</param>
485	/// <returns>The elements of the column.</returns>
486	/// <exception cref="ArgumentOutOfRangeException">Is thrown when the index is out of range.</exception>
487	public List<T>? GetColumnData(int index)
488	{
489	if (_rawLines is null)	9!
490	{
491	return null;	×
492	}
493
494	if (index < 0 \|\| index >= _rawLines[0].Count)	9!
495	{
496	throw new ArgumentOutOfRangeException(nameof(index), "Invalid column index.");	×
497	}
498
499	List<T>? list = new();	9✔
500	for (int i = 0; i < _rawLines.Count; i++)	144✔
501	{
502	list.Add(_rawLines[i][index]);	63✔
503	}
504	return list;	9✔
505	}
506
507	/// <summary>
508	/// This method is used to get all the elements from a column given its header.
509	/// </summary>
510	/// <param name="header">The header of the column.</param>
511	/// <returns>The elements of the column.</returns>
512	/// <exception cref="InvalidOperationException">Is thrown when the table is empty.</exception>
513	/// <exception cref="ArgumentOutOfRangeException">Is thrown when the header is invalid.</exception>
514	public List<T>? GetColumnData(string header)
515	{
516	if (_rawHeaders is null)	9!
517	{
518	throw new InvalidOperationException("The headers are null.");	×
519	}
520	else if (_rawLines is null)	9!
521	{
522	return null;	×
523	}
524	if (!_rawHeaders.Contains(header))	9!
525	{
526	throw new ArgumentOutOfRangeException(nameof(header), "Invalid column header.");	×
527	}
528
529	return GetColumnData(_rawHeaders.IndexOf(header));	9✔
530	}
531
532	/// <summary>
533	/// This method adds a line to the table.
534	/// </summary>
535	/// <param name="line">The line to add.</param>
536	/// <exception cref="ArgumentException">Is thrown when the number of columns in the table is not consistent with itself or with the headers.</exception>
537	/// <remarks>Refer to the example project to understand how to implement it available at https://github.com/MorganKryze/ConsoleAppVisuals/blob/main/example/Program.cs </remarks>
538	public void AddLine(List<T> line)
539	{
540	if (_rawLines?.Count > 0 && line.Count != _rawLines[0].Count)	270!
541	{
542	throw new ArgumentException(	×
543	"The number of columns in the table is not consistent with other lines."	×
544	);	×
545	}
546	if (_rawHeaders is not null && line.Count != _rawHeaders.Count)	270!
547	{
548	throw new ArgumentException(	×
549	"The number of columns in the table is not consistent with the headers."	×
550	);	×
551	}
552	_rawLines ??= new List<List<T>>();	270✔
553	_rawLines.Add(line);	270✔
554	BuildTable();	270✔
555	}	270✔
556
557	/// <summary>
558	/// This method removes a line from the table.
559	/// </summary>
560	/// <param name="index">The index of the line to remove.</param>
561	/// <exception cref="ArgumentOutOfRangeException">Is thrown when the index is out of range.</exception>
562	/// <remarks>Refer to the example project to understand how to implement it available at https://github.com/MorganKryze/ConsoleAppVisuals/blob/main/example/Program.cs </remarks>
563	public void RemoveLine(int index)
564	{
565	if (_rawLines?.Count > 0 && (index < 0 \|\| index >= _rawLines.Count))	×
566	{
567	throw new ArgumentOutOfRangeException(nameof(index), "The index is out of range.");	×
568	}
569
570	_rawLines?.RemoveAt(index);	×
571	BuildTable();	×
572	}	×
573
574	/// <summary>
575	/// This method updates a line in the table.
576	/// </summary>
577	/// <param name="index">The index of the line to update.</param>
578	/// <param name="line">The new line.</param>
579	/// <exception cref="ArgumentOutOfRangeException">Is thrown when the index is out of range.</exception>
580	/// <exception cref="ArgumentException">Is thrown when the number of columns in the table is not consistent with itself or with the headers.</exception>
581	/// <remarks>Refer to the example project to understand how to implement it available at https://github.com/MorganKryze/ConsoleAppVisuals/blob/main/example/Program.cs </remarks>
582	public void UpdateLine(int index, List<T> line)
583	{
584	if (_rawLines?.Count > 0)	×
585	{
586	if (index < 0 \|\| index >= _rawLines.Count)	×
587	{
588	throw new ArgumentOutOfRangeException(nameof(index), "The index is out of range.");	×
589	}
590
591	if (line.Count != _rawHeaders?.Count)	×
592	{
593	throw new ArgumentException(	×
594	"The number of columns in the table is not consistent."	×
595	);	×
596	}
597	}
598	_rawLines![index] = line;	×
599	BuildTable();	×
600	}	×
601
602	/// <summary>
603	/// This method clears the headers of the table.
604	/// </summary>
605	public void ClearHeaders()
606	{
607	_rawHeaders = null;	×
608	BuildTable();	×
609	}	×
610
611	/// <summary>
612	/// This method clears the lines of the table.
613	/// </summary>
614	public void ClearLines()
615	{
616	_rawLines = null;	×
617	BuildTable();	×
618	}	×
619
620	/// <summary>
621	/// This method clears the table.
622	/// </summary>
623	public void Reset()
624	{
625	_title = null;	×
626	_rawHeaders?.Clear();	×
627	_rawLines?.Clear();	×
628	_displayArray = null;	×
629	}	×
630	#endregion
631
632	#region Display Methods
633	/// <summary>
634	/// This method displays the table without interaction.
635	/// </summary>
636	protected override void RenderElementActions()
637	{
638	string[] array = new string[_displayArray!.Length];	×
639	for (int j = 0; j < _displayArray.Length; j++)	×
640	{
641	array[j] = _displayArray[j];	×
642	Core.WritePositionedString(	×
643	array[j],	×
644	_placement.ToTextAlignment(),	×
645	false,	×
646	_line + j	×
647	);	×
648	}
649	}	×
650	#endregion
651	}

MorganKryze / ConsoleAppVisuals / 7473956714

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous