Remove Unused files and code

BudgetAnalyser.Encryption/BudgetAnalyser.Encryption.csproj

@@ -1,23 +1,27 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-    <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
-    <Version>4.0.0</Version>
-    <AssemblyVersion>4.0.0</AssemblyVersion>
-    <FileVersion>4.0.0</FileVersion>
-  </PropertyGroup>
+    <PropertyGroup>
+        <TargetFramework>net8.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
+        <Version>4.0.0</Version>
+        <AssemblyVersion>4.0.0</AssemblyVersion>
+        <FileVersion>4.0.0</FileVersion>
+    </PropertyGroup>
 
-  <ItemGroup>
-    <PackageReference Include="ConfuzzleCore" Version="3.0.2" />
-    <PackageReference Include="JetBrains.Annotations" Version="2024.2.0" />
-    <PackageReference Include="Rees.TangyFruitMapper" Version="2.0.0" />
-  </ItemGroup>
+    <ItemGroup>
+        <PackageReference Include="ConfuzzleCore" Version="3.0.2"/>
+        <PackageReference Include="JetBrains.Annotations" Version="2024.2.0"/>
+        <PackageReference Include="Rees.TangyFruitMapper" Version="2.0.0"/>
+    </ItemGroup>
 
-  <ItemGroup>
-    <ProjectReference Include="..\BudgetAnalyser.Engine\BudgetAnalyser.Engine.csproj" />
-  </ItemGroup>
+    <ItemGroup>
+        <InternalsVisibleTo Include="BudgetAnalyser.Engine.UnitTest"/>
+    </ItemGroup>
+
+    <ItemGroup>
+        <ProjectReference Include="..\BudgetAnalyser.Engine\BudgetAnalyser.Engine.csproj"/>
+    </ItemGroup>
 
 </Project>

BudgetAnalyser.Encryption/EncryptedLocalDiskReaderWriter.cs

@@ -1,136 +1,114 @@
-using System;
-using System.IO;
-using System.Linq;
-using System.Security;
-using System.Threading.Tasks;
+using System.Security;
 using BudgetAnalyser.Engine;
 using BudgetAnalyser.Engine.Persistence;
 using BudgetAnalyser.Engine.Services;
-using JetBrains.Annotations;
 
-namespace BudgetAnalyser.Encryption
+namespace BudgetAnalyser.Encryption;
+
+[AutoRegisterWithIoC(Named = "Encrypted")]
+internal class EncryptedLocalDiskReaderWriter(IFileEncryptor fileEncryptor, ICredentialStore credentialStore) : IFileReaderWriter
 {
-    [AutoRegisterWithIoC(Named = "Encrypted")]
-    internal class EncryptedLocalDiskReaderWriter : IFileReaderWriter
+    private readonly ICredentialStore credentialStore = credentialStore ?? throw new ArgumentNullException(nameof(credentialStore));
+    private readonly IFileEncryptor fileEncryptor = fileEncryptor ?? throw new ArgumentNullException(nameof(fileEncryptor));
+
+    public Stream CreateWritableStream(string fileName)
     {
-        private readonly ICredentialStore credentialStore;
-        private readonly IFileEncryptor fileEncryptor;
+        return this.fileEncryptor.CreateWritableEncryptedStream(fileName, RetrievePassword());
+    }
 
-        public EncryptedLocalDiskReaderWriter([NotNull] IFileEncryptor fileEncryptor, [NotNull] ICredentialStore credentialStore)
-        {
-            if (fileEncryptor is null)
-            {
-                throw new ArgumentNullException(nameof(fileEncryptor));
-            }
-
-            if (credentialStore is null)
-            {
-                throw new ArgumentNullException(nameof(credentialStore));
-            }
-
-            this.fileEncryptor = fileEncryptor;
-            this.credentialStore = credentialStore;
-        }
+    /// <summary>
+    ///     Files the exists.
+    /// </summary>
+    /// <param name="fileName">Full path and filename of the file.</param>
+    public bool FileExists(string fileName)
+    {
+        return File.Exists(fileName);
+    }
 
-        public Stream CreateWritableStream(string fileName)
+    /// <summary>
+    ///     Loads a budget collection xaml file from disk.
+    /// </summary>
+    /// <param name="fileName">Full path and filename of the file.</param>
+    public async Task<string> LoadFromDiskAsync(string fileName)
+    {
+        if (fileName.IsNothing())
         {
-            return this.fileEncryptor.CreateWritableEncryptedStream(fileName, RetrievePassword());
+            throw new ArgumentNullException(nameof(fileName));
         }
 
-        /// <summary>
-        ///     Files the exists.
-        /// </summary>
-        /// <param name="fileName">Full path and filename of the file.</param>
-        public bool FileExists(string fileName)
-        {
-            return File.Exists(fileName);
-        }
+        var password = RetrievePassword();
+        var decryptedData = await this.fileEncryptor.LoadEncryptedFileAsync(fileName, password);
+
+        return IsValidAlphaNumericWithPunctuation(decryptedData)
+            ? decryptedData
+            : throw new EncryptionKeyIncorrectException("The provided encryption credential did not result in a valid decryption result.");
+    }
 
-        /// <summary>
-        ///     Loads a budget collection xaml file from disk.
-        /// </summary>
-        /// <param name="fileName">Full path and filename of the file.</param>
-        public async Task<string> LoadFromDiskAsync(string fileName)
+    /// <summary>
+    ///     Loads a budget collection xaml file from disk.
+    /// </summary>
+    /// <param name="fileName">Full path and filename of the file.</param>
+    /// <param name="lineCount">The number of lines to load.</param>
+    public async Task<string> LoadFirstLinesFromDiskAsync(string fileName, int lineCount)
+    {
+        if (fileName.IsNothing())
         {
-            if (fileName.IsNothing())
-            {
-                throw new ArgumentNullException(nameof(fileName));
-            }
+            throw new ArgumentNullException(nameof(fileName));
+        }
 
-            var password = RetrievePassword();
-            var decryptedData = await this.fileEncryptor.LoadEncryptedFileAsync(fileName, password);
+        var decryptedData = await this.fileEncryptor.LoadFirstLinesFromDiskAsync(fileName, lineCount, RetrievePassword());
+        return IsValidAlphaNumericWithPunctuation(decryptedData)
+            ? decryptedData
+            : throw new EncryptionKeyIncorrectException("The provided encryption credential did not result in a valid decryption result.");
+    }
 
-            return IsValidAlphaNumericWithPunctuation(decryptedData)
-                ? decryptedData
-                : throw new EncryptionKeyIncorrectException("The provided encryption credential did not result in a valid decryption result.");
+    /// <summary>
+    ///     Writes the budget collections to a xaml file on disk.
+    /// </summary>
+    public async Task WriteToDiskAsync(string fileName, string data)
+    {
+        if (fileName.IsNothing())
+        {
+            throw new ArgumentNullException(nameof(fileName));
         }
 
-        /// <summary>
-        ///     Loads a budget collection xaml file from disk.
-        /// </summary>
-        /// <param name="fileName">Full path and filename of the file.</param>
-        /// <param name="lineCount">The number of lines to load.</param>
-        public async Task<string> LoadFirstLinesFromDiskAsync(string fileName, int lineCount)
+        if (data.IsNothing())
         {
-            if (fileName.IsNothing())
-            {
-                throw new ArgumentNullException(nameof(fileName));
-            }
-
-            var decryptedData = await this.fileEncryptor.LoadFirstLinesFromDiskAsync(fileName, lineCount, RetrievePassword());
-            return IsValidAlphaNumericWithPunctuation(decryptedData)
-                ? decryptedData
-                : throw new EncryptionKeyIncorrectException("The provided encryption credential did not result in a valid decryption result.");
+            throw new ArgumentNullException(nameof(data));
         }
 
-        /// <summary>
-        ///     Writes the budget collections to a xaml file on disk.
-        /// </summary>
-        public async Task WriteToDiskAsync(string fileName, string data)
+        var password = RetrievePassword();
+        await this.fileEncryptor.SaveStringDataToEncryptedFileAsync(fileName, data, password);
+    }
+
+    internal bool IsValidAlphaNumericWithPunctuation(string? text)
+    {
+        if (text is null)
         {
-            if (fileName.IsNothing())
-            {
-                throw new ArgumentNullException(nameof(fileName));
-            }
-
-            if (data.IsNothing())
-            {
-                throw new ArgumentNullException(nameof(data));
-            }
-
-            var password = RetrievePassword();
-            await this.fileEncryptor.SaveStringDataToEncryptedFileAsync(fileName, data, password);
+            return false;
         }
 
-        internal bool IsValidAlphaNumericWithPunctuation(string text)
-        {
-            if (text is null)
-            {
-                return false;
-            }
+        var valid = text.ToCharArray().Take(16).All(IsValidUtf8AlphaNumericWithPunctuation);
+        return valid;
+    }
 
-            var valid = text.ToCharArray().Take(16).All(IsValidUtf8AlphaNumericWithPunctuation);
-            return valid;
-        }
+    private bool IsValidUtf8AlphaNumericWithPunctuation(char c)
+    {
+        // 0x0000007e is Tilde which is considered valid.
+        // 0x00000000 is a null character which is invalid.
+        // Everything beyond 0x0000007f is considered invalid as it is not plain text.
+        var valid = c < 0x0000007f && c > 0x00000000;
+        return valid;
+    }
 
-        private bool IsValidUtf8AlphaNumericWithPunctuation(char c)
+    private SecureString RetrievePassword()
+    {
+        if (this.credentialStore.RetrievePasskey() is not SecureString password)
         {
-            // 0x0000007e is Tilde which is considered valid.
-            // 0x00000000 is a null character which is invalid.
-            // Everything beyond 0x0000007f is considered invalid as it is not plain text.
-            var valid = c < 0x0000007f && c > 0x00000000;
-            return valid;
+            // This condition should be checked by the UI before calling into the Engine ideally.
+            throw new EncryptionKeyNotProvidedException("Attempt to load an encrypted password protected file and no password has been set.");
         }
 
-        private SecureString RetrievePassword()
-        {
-            if (this.credentialStore.RetrievePasskey() is not SecureString password)
-            {
-                // This condition should be checked by the UI before calling into the Engine ideally.
-                throw new EncryptionKeyNotProvidedException("Attempt to load an encrypted password protected file and no password has been set.");
-            }
-
-            return password;
-        }
+        return password;
     }
 }

BudgetAnalyser.Encryption/FileEncryptor.cs

@@ -10,6 +10,7 @@ namespace BudgetAnalyser.Encryption;
 ///     A utility class for encrypting files on the local disk.
 /// </summary>
 [AutoRegisterWithIoC(SingleInstance = true)]
+// ReSharper disable once UnusedType.Global // Instantiated by IoC
 internal class FileEncryptor : IFileEncryptor
 {
     [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Output stream is disposed by consumer when CipherStream is disposed")]
@@ -19,31 +20,6 @@ public Stream CreateWritableEncryptedStream(string fileName, SecureString passph
         return CipherStream.Create(outputStream, SecureStringCredentialStore.SecureStringToString(passphrase));
     }
 
-    public async Task EncryptFileAsync(string sourceFile, string destinationFile, SecureString passphrase)
-    {
-        if (sourceFile.IsNothing())
-        {
-            throw new ArgumentNullException(nameof(sourceFile));
-        }
-
-        if (destinationFile.IsNothing())
-        {
-            throw new ArgumentNullException(nameof(destinationFile));
-        }
-
-        if (passphrase is null)
-        {
-            throw new ArgumentNullException(nameof(passphrase));
-        }
-
-        if (!FileExists(sourceFile))
-        {
-            throw new FileNotFoundException(sourceFile);
-        }
-
-        await Confuzzle.EncryptFile(sourceFile).WithPassword(passphrase).IntoFile(destinationFile);
-    }
-
     public async Task<string> LoadEncryptedFileAsync(string fileName, SecureString passphrase)
     {
         return await Confuzzle.DecryptFile(fileName).WithPassword(passphrase).IntoString();
@@ -59,7 +35,7 @@ public async Task<string> LoadFirstLinesFromDiskAsync(string fileName, int lineC
             while (cryptoStream.CanRead)
             {
                 var buffer = new byte[4096];
-                await cryptoStream.ReadAsync(buffer, 0, 4096);
+                await cryptoStream.ReadExactlyAsync(buffer, 0, 4096);
                 await outputStream.WriteAsync(buffer, 0, 4096);
                 var chunk = Encoding.UTF8.GetChars(buffer);
                 var occurrences = chunk.Count(c => c == '\n');

BudgetAnalyser.Encryption/GlobalSuppressions.cs

@@ -1,14 +1,14 @@
 using System.Runtime.CompilerServices;
 
-// This file is used by Code Analysis to maintain SuppressMessage 
+// This file is used by Code Analysis to maintain SuppressMessage
 // attributes that are applied to this project.
-// Project-level suppressions either have no target or are given 
+// Project-level suppressions either have no target or are given
 // a specific target and scoped to a namespace, type, member, etc.
 //
-// To add a suppression to this file, right-click the message in the 
-// Code Analysis results, point to "Suppress Message", and click 
+// To add a suppression to this file, right-click the message in the
+// Code Analysis results, point to "Suppress Message", and click
 // "In Suppression File".
 // You do not need to add suppressions to this file manually.
-[assembly: InternalsVisibleTo("BudgetAnalyser.Engine.UnitTest")]
+
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA2210:AssembliesShouldHaveValidStrongNames")]
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "BudgetAnalyser.Encryption")]