12209957165

Committed 07 Dec 2024 04:31AM UTC coverage: 78.659% (+0.3%) from 78.362%

Build # 12209957165

Build Type

push

github

Committed by

JaCraig

Commit Message

feat: Add XLS format support with tests and dependencies

Added support for XLS format in the Archivist library:
- Updated `Archivist.Tests.csproj` to include `TestXLS.xls` with `CopyToOutputDirectory` set to `PreserveNewest`.
- Updated `Archivist.csproj` to add `ExcelDataReader` v3.7.0 and `System.Text.Encoding.CodePages` v9.0.0.
- Registered `System.Text.CodePagesEncodingProvider` in `ServiceCollectionExtensionMethods.cs`.
- Updated `HeaderInfo` in `XMLReader.cs` to use a UTF-8 encoded string.
- Added new test classes: `XLSFormatTests.cs`, `XLSReaderTests.cs`, and `XLSWriterTests.cs` to verify XLS format functionality.
- Created `XLSFormat`, `XLSReader`, and `XLSWriter` classes to handle XLS file operations.

Run Details

2428 of 3344 branches covered (72.61%)

Branch coverage included in aggregate %.

40 of 44 new or added lines in 5 files covered. (90.91%)

4 existing lines in 1 file now uncovered.

3193 of 3802 relevant lines covered (83.98%)

12467.29 hits per line

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

87.3

/Archivist/Formats/XLS/XLSReader.cs

﻿using Archivist.BaseClasses;
using Archivist.Converters;
using Archivist.Interfaces;
using Archivist.Options;
using ExcelDataReader;
using System;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Archivist.Formats.XLS
{
    /// <summary>
    /// Represents a reader for XLS files.
    /// </summary>
    /// <seealso cref="ReaderBaseClass"/>
    /// <remarks>Initializes a new instance of the <see cref="XLSReader"/> class.</remarks>
    /// <param name="options">The XLS options.</param>
    /// <param name="converter">The converter.</param>
    public class XLSReader(ExcelOptions? options, Convertinator? converter)
        : ReaderBaseClass
    {
        /// <summary>
        /// Gets the header information for XLS files.
        /// </summary>
        public override byte[] HeaderInfo { get; } = new byte[] { 0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1 };

        /// <summary>
        /// Gets the XLS options.
        /// </summary>
        private ExcelOptions Options { get; } = options ?? ExcelOptions.Default;

        /// <summary>
        /// The converter.
        /// </summary>
        private readonly Convertinator? _Converter = converter;

        /// <summary>
        /// Determines if the reader can read the given stream as an XLS file.
        /// </summary>
        /// <param name="stream">The stream to read.</param>
        /// <returns>True if the reader can read the file, false otherwise.</returns>
        public override bool InternalCanRead(Stream? stream)
        {
            if (stream is null || !IsValidStream(stream))
                return false;
            try
            {
                using IExcelDataReader Reader = ExcelReaderFactory.CreateReader(stream);
                return Reader.Read();
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// Reads the XLS file asynchronously and returns the data as a generic file.
        /// </summary>
        /// <param name="stream">The stream to read.</param>
        /// <returns>
        /// A task representing the asynchronous operation. The task result is the generic file data.
        /// </returns>
        public override Task<IGenericFile?> ReadAsync(Stream? stream)
        {
            var ReturnValue = new DataTypes.Tables(_Converter);
            if (stream is null || !IsValidStream(stream))
                return Task.FromResult<IGenericFile?>(ReturnValue);
            try
            {
                using IExcelDataReader Reader = ExcelReaderFactory.CreateReader(stream, new ExcelReaderConfiguration()
                {
                    FallbackEncoding = Encoding.GetEncoding(1252)
                });
                do
                {
                    DataTypes.Table CurrentTable = ReturnValue.AddTable();
                    CurrentTable.Title = Reader.Name;
                    while (Reader.Read())
                    {
                        DataTypes.TableRow CurrentRow = CurrentTable.AddRow();
                        for (var X = 0; X < Reader.FieldCount; ++X)
                        {
                            CurrentRow.Add(new DataTypes.TableCell(Reader.GetValue(X)?.ToString() ?? ""));
                        }
                    }
                    if (Options.FirstRowIsColumnHeaders)
                    {
                        CurrentTable.Columns.AddRange(CurrentTable[0].Select(x => x.Content ?? "") ?? []);
                        CurrentTable.RemoveAt(0);
                    }
                    else
                    {
                        for (var X = 0; X < CurrentTable[0].Count; ++X)
                        {
                            CurrentTable.Columns.Add($"Column {X + 1}");
                        }
                    }
                } while (Reader.NextResult());
            }
            catch (Exception)
            {
                return Task.FromResult<IGenericFile?>(ReturnValue);
            }

            return Task.FromResult<IGenericFile?>(ReturnValue);
        }
    }
}

1	using Archivist.BaseClasses;
2	using Archivist.Converters;
3	using Archivist.Interfaces;
4	using Archivist.Options;
5	using ExcelDataReader;
6	using System;
7	using System.IO;
8	using System.Linq;
9	using System.Text;
10	using System.Threading.Tasks;
11
12	namespace Archivist.Formats.XLS
13	{
14	/// <summary>
15	/// Represents a reader for XLS files.
16	/// </summary>
17	/// <seealso cref="ReaderBaseClass"/>
18	/// <remarks>Initializes a new instance of the <see cref="XLSReader"/> class.</remarks>
19	/// <param name="options">The XLS options.</param>
20	/// <param name="converter">The converter.</param>
21	public class XLSReader(ExcelOptions? options, Convertinator? converter)	32✔
22	: ReaderBaseClass
23	{
24	/// <summary>
25	/// Gets the header information for XLS files.
26	/// </summary>
27	public override byte[] HeaderInfo { get; } = new byte[] { 0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1 };	41✔
28
29	/// <summary>
30	/// Gets the XLS options.
31	/// </summary>
32	private ExcelOptions Options { get; } = options ?? ExcelOptions.Default;	34✔
33
34	/// <summary>
35	/// The converter.
36	/// </summary>
37	private readonly Convertinator? _Converter = converter;	32✔
38
39	/// <summary>
40	/// Determines if the reader can read the given stream as an XLS file.
41	/// </summary>
42	/// <param name="stream">The stream to read.</param>
43	/// <returns>True if the reader can read the file, false otherwise.</returns>
44	public override bool InternalCanRead(Stream? stream)
45	{
46	if (stream is null \|\| !IsValidStream(stream))	2✔
47	return false;	1✔
48	try
49	{
50	using IExcelDataReader Reader = ExcelReaderFactory.CreateReader(stream);	1✔
51	return Reader.Read();	1✔
52	}
NEW 53	catch	×
54	{
NEW 55	return false;	×
56	}
57	}	1✔
58
59	/// <summary>
60	/// Reads the XLS file asynchronously and returns the data as a generic file.
61	/// </summary>
62	/// <param name="stream">The stream to read.</param>
63	/// <returns>
64	/// A task representing the asynchronous operation. The task result is the generic file data.
65	/// </returns>
66	public override Task<IGenericFile?> ReadAsync(Stream? stream)
67	{
68	var ReturnValue = new DataTypes.Tables(_Converter);	93✔
69	if (stream is null \|\| !IsValidStream(stream))	93✔
70	return Task.FromResult<IGenericFile?>(ReturnValue);	90✔
71	try
72	{
73	using IExcelDataReader Reader = ExcelReaderFactory.CreateReader(stream, new ExcelReaderConfiguration()	3✔
74	{	3✔
75	FallbackEncoding = Encoding.GetEncoding(1252)	3✔
76	});	3✔
77	do
78	{
79	DataTypes.Table CurrentTable = ReturnValue.AddTable();	2✔
80	CurrentTable.Title = Reader.Name;	2✔
81	while (Reader.Read())	8✔
82	{
83	DataTypes.TableRow CurrentRow = CurrentTable.AddRow();	6✔
84	for (var X = 0; X < Reader.FieldCount; ++X)	36✔
85	{
86	CurrentRow.Add(new DataTypes.TableCell(Reader.GetValue(X)?.ToString() ?? ""));	12✔
87	}
88	}
89	if (Options.FirstRowIsColumnHeaders)	2!
90	{
91	CurrentTable.Columns.AddRange(CurrentTable[0].Select(x => x.Content ?? "") ?? []);	6!
92	CurrentTable.RemoveAt(0);	2✔
93	}
94	else
95	{
NEW 96	for (var X = 0; X < CurrentTable[0].Count; ++X)	×
97	{
NEW 98	CurrentTable.Columns.Add($"Column {X + 1}");	×
99	}
100	}
101	} while (Reader.NextResult());	2✔
102	}	2✔
103	catch (Exception)	1✔
104	{
105	return Task.FromResult<IGenericFile?>(ReturnValue);	1✔
106	}
107
108	return Task.FromResult<IGenericFile?>(ReturnValue);	2✔
109	}	1✔
110	}
111	}

JaCraig / Archivist / 12209957165

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