Split Luhn class

- Clear separation of concerns:
  The project is well-structured, with distinct classes for calculation (`LuhnCalculator`), validation (`LuhnValidator`), and core algorithm logic (`LuhnAlgorithm`).
  This promotes maintainability and testability.
- Extension methods:
  The use of extension methods for string manipulation and validation provides a fluent and convenient API.

Resolves: No entry

Author: shinji-san

CHANGELOG.md

@@ -6,29 +6,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 ### Added
-- Add `InvalidCharacterException` to throw an exception if the input string contains invalid characters.
-- Add `RemoveSeparators` method to remove all separators from a string. Use it, for example, with credit card numbers.
+- Added `InvalidCharacterException` to throw an exception if the input string contains invalid characters.
+- Added `RemoveSeparators` methods to remove all separators from a string or ReadOnlySpan. Use it, for example, with credit card numbers.
 
 ### Changed
-- Renamed `Luhn.ConvertAlphaNumericToNumeric` to `Luhn.AlphaNumericToNumeric`
+- Renamed `ConvertAlphaNumericToNumeric` to `AlphaNumericToNumeric`
+- Moved `AlphaNumericToNumeric` method to the `StringExtensions` and `ReadOnlySpanExtensions` classes.
+- Moved `ComputeCheckDigit` and `ComputeLuhnNumber` methods to the `LuhnCalculator` class.
+- Moved `IsValidNumber` and `IsValidCheckDigit` methods to the `LuhnValidator` class.
+- Renamed `Luhn` class to `LuhnAlgorithm`.
 
 ### Removed
 - Removed `Luhn.IsValid` methods
 
 ## [1.3.0] - 2024-12-27
 ### Added
-- Add project icon
-- Add project social preview image
-- Add `Luhn.IsValidNumber`
-- Add `Luhn.IsValidCheckDigit`
+- Added project icon
+- Added project social preview image
+- Added `Luhn.IsValidNumber`
+- Added `Luhn.IsValidCheckDigit`
 
 ### Deprecated
 - `Luhn.IsValid` methods are deprecated. Use `Luhn.IsValidNumber` or `Luhn.IsValidCheckDigit` instead.
 
 ## [1.2.0] - 2024-12-26
 ### Added
-- Add [API documentation](https://sebastian-walther.de/LuhnDotNet/api/LuhnDotNet.html)
-- Add .NET 9 support
+- Added [API documentation](https://sebastian-walther.de/LuhnDotNet/api/LuhnDotNet.html)
+- Added .NET 9 support
 
 ### Removed
 - Removed .NET 7 support
@@ -37,7 +41,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [1.1.0] - 2024-03-30
 ### Added
-- Add `ConvertAlphaNumericToNumeric` method to convert a string containing alphanumeric characters to a string containing only numeric characters (use case: converting an ISIN to a numeric string for Luhn validation).
+- Added `ConvertAlphaNumericToNumeric` method to convert a string containing alphanumeric characters to a string containing only numeric characters (use case: converting an ISIN to a numeric string for Luhn validation).
 
 ## [1.0.1] - 2024-03-19
 ### Fixed

benchmark/LuhnDotNetBenchmark.cs

@@ -5,7 +5,9 @@ namespace LuhnDotNetBenchmark;
 using LuhnDotNet;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 
+[ExcludeFromCodeCoverage]
 [MemoryDiagnoser]
 [GroupBenchmarksBy(BenchmarkLogicalGroupRule.ByCategory)]
 [CategoriesColumn]
@@ -15,66 +17,146 @@ public class LuhnDotNetBenchmark
     private const string ComputeLuhnCheckDigitCategory = "Compute Luhn check digit";
     private const string IsValidLuhnNumberCategory = "Validate Luhn number";
     private const string IsValidLuhnCheckDigitCategory = "Validate Luhn check digit";
+    private const string AlphaNumericToNumericCategory = "AlphaNumeric to Numeric";
+    private const string RemoveSeparatorCategory = "Remove separators";
+    private const string ValidationChainCategory = "Validation chain";
+    private const string ComputeChainCategory = "Compute chain";
 
-    public static IEnumerable<string> NumbersAsString()
+    public static IEnumerable<string> NumericNumbersAsString()
     {
         yield return "79927398713";
         yield return "79927398718234234134645645645624563445654634343462545462546546245624356245625624565265432";
     }
 
+    public static IEnumerable<string> AlphaNumericNumbersAsString()
+    {
+        yield return "US79927398713";
+        yield return "79927398713DE";
+        yield return "ABCDEF";
+        yield return "DE79927398718234234134645645645624563445654634343462545462546546245624356245625624565265432";
+    }
+
+    public static IEnumerable<string> SeparatedNumbersAsString()
+    {
+        yield return "7992-7398-7134";
+        yield return "79927398/71823423413464564564562456344565463434346254546254654/6245624356245625624565265432";
+    }
+    
+    public static IEnumerable<string> SeparatedAlphaNumericNumbersAsString()
+    {
+        yield return "US-7992-7398-7134";
+        yield return "A7992-B7398-C7134";
+    }
+
     [Benchmark(Baseline = true), BenchmarkCategory(ComputeLuhnNumberCategory)]
-    [ArgumentsSource(nameof(NumbersAsString))]
+    [ArgumentsSource(nameof(NumericNumbersAsString))]
     public void ComputeLuhnNumberBasedOnString(string number)
     {
         number.ComputeLuhnNumber();
     }
 
     [Benchmark(Baseline = true), BenchmarkCategory(ComputeLuhnCheckDigitCategory)]
-    [ArgumentsSource(nameof(NumbersAsString))]
+    [ArgumentsSource(nameof(NumericNumbersAsString))]
     public void ComputeLuhnCheckDigitBasedOnString(string number)
     {
         number.ComputeLuhnCheckDigit();
     }
 
     [Benchmark(Baseline = true), BenchmarkCategory(IsValidLuhnNumberCategory)]
-    [ArgumentsSource(nameof(NumbersAsString))]
+    [ArgumentsSource(nameof(NumericNumbersAsString))]
     public void IsValidLuhnNumberBasedOnString(string number)
     {
         number.IsValidLuhnNumber();
     }
 
     [Benchmark(Baseline = true), BenchmarkCategory(IsValidLuhnCheckDigitCategory)]
-    [ArgumentsSource(nameof(NumbersAsString))]
+    [ArgumentsSource(nameof(NumericNumbersAsString))]
     public void IsValidLuhnCheckDigitBasedOnString(string number)
     {
         byte.MinValue.IsValidLuhnCheckDigit(number);
     }
 
     [Benchmark, BenchmarkCategory(ComputeLuhnNumberCategory)]
-    [ArgumentsSource(nameof(NumbersAsString))]
+    [ArgumentsSource(nameof(NumericNumbersAsString))]
     public void ComputeLuhnNumberBasedOnSpan(string number)
     {
         number.AsSpan().ComputeLuhnNumber();
     }
 
     [Benchmark, BenchmarkCategory(ComputeLuhnCheckDigitCategory)]
-    [ArgumentsSource(nameof(NumbersAsString))]
+    [ArgumentsSource(nameof(NumericNumbersAsString))]
     public void ComputeLuhnCheckDigitBasedOnSpan(string number)
     {
         number.AsSpan().ComputeLuhnCheckDigit();
     }
 
     [Benchmark, BenchmarkCategory(IsValidLuhnNumberCategory)]
-    [ArgumentsSource(nameof(NumbersAsString))]
+    [ArgumentsSource(nameof(NumericNumbersAsString))]
     public void IsValidLuhnNumberBasedOnSpan(string number)
     {
         number.AsSpan().IsValidLuhnNumber();
     }
 
     [Benchmark, BenchmarkCategory(IsValidLuhnCheckDigitCategory)]
-    [ArgumentsSource(nameof(NumbersAsString))]
+    [ArgumentsSource(nameof(NumericNumbersAsString))]
     public void IsValidLuhnCheckDigitBasedOnSpan(string number)
     {
         byte.MinValue.IsValidLuhnCheckDigit(number.AsSpan());
     }
-}
+
+    [Benchmark(Baseline = true), BenchmarkCategory(AlphaNumericToNumericCategory)]
+    [ArgumentsSource(nameof(AlphaNumericNumbersAsString))]
+    public void AlphaNumericToNumericBasedOnString(string number)
+    {
+        number.AlphaNumericToNumeric();
+    }
+
+    [Benchmark, BenchmarkCategory(AlphaNumericToNumericCategory)]
+    [ArgumentsSource(nameof(AlphaNumericNumbersAsString))]
+    public void AlphaNumericToNumericBasedOnSpan(string number)
+    {
+        number.AsSpan().AlphaNumericToNumeric();
+    }
+
+    [Benchmark(Baseline = true), BenchmarkCategory(RemoveSeparatorCategory)]
+    [ArgumentsSource(nameof(SeparatedNumbersAsString))]
+    public void RemoveSeparatorBasedOnString(string number)
+    {
+        number.RemoveSeparators();
+    }
+
+    [Benchmark, BenchmarkCategory(RemoveSeparatorCategory)]
+    [ArgumentsSource(nameof(SeparatedNumbersAsString))]
+    public void RemoveSeparatorBasedOnSpan(string number)
+    {
+        number.AsSpan().RemoveSeparators();
+    }
+
+    [Benchmark(Baseline = true), BenchmarkCategory(ComputeChainCategory)]
+    [ArgumentsSource(nameof(SeparatedAlphaNumericNumbersAsString))]
+    public void ComputeChainBasedOnString(string number)
+    {
+        number.RemoveSeparators().AlphaNumericToNumeric().ComputeLuhnNumber();
+    }
+
+    [Benchmark, BenchmarkCategory(ComputeChainCategory)]
+    [ArgumentsSource(nameof(SeparatedAlphaNumericNumbersAsString))]
+    public void ComputeChainBasedOnSpan(string number)
+    {
+        number.AsSpan().RemoveSeparators().AlphaNumericToNumeric().ComputeLuhnNumber();
+    }
+
+    [Benchmark(Baseline = true), BenchmarkCategory(ValidationChainCategory)]
+    [ArgumentsSource(nameof(SeparatedAlphaNumericNumbersAsString))]
+    public void ValidationChainBasedOnString(string number)
+    {
+        number.RemoveSeparators().AlphaNumericToNumeric().IsValidLuhnNumber();
+    }
+
+    [Benchmark, BenchmarkCategory(ValidationChainCategory)]
+    [ArgumentsSource(nameof(SeparatedAlphaNumericNumbersAsString))]
+    public void ValidationChainBasedOnSpan(string number)
+    {
+        number.AsSpan().RemoveSeparators().AlphaNumericToNumeric().IsValidLuhnNumber();
+    }
+}

benchmark/Program.cs

@@ -1,3 +1,10 @@
-using BenchmarkDotNet.Running;
+namespace LuhnDotNetBenchmark;
 
-BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);
+using BenchmarkDotNet.Running;
+using System.Diagnostics.CodeAnalysis;
+
+[ExcludeFromCodeCoverage]
+public static class Program
+{
+    public static void Main(string[] args) => BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);
+}