Merge pull request #85 from shinji-san/fix-ConverterMethodName

Rename ConvertAlphaNumericToNumeric to AlphaNumericToNumeric

Resolves: #85

Author: shinji-san

CHANGELOG.md

@@ -5,6 +5,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+### Changed
+- Renamed `Luhn.ConvertAlphaNumericToNumeric` to `Luhn.AlphaNumericToNumeric`
+
 ### Removed
 - Removed `Luhn.IsValid` methods
 

README.md

@@ -212,11 +212,11 @@ namespace Example4
 }
 ```
 
-## Validate ISIN with LuhnDotNet and ConvertAlphaNumericToNumeric
+## Validate ISIN with LuhnDotNet and AlphaNumericToNumeric
 
-The `LuhnDotNet` library can be used in combination with the `ConvertAlphaNumericToNumeric` method to validate an International Securities Identification Number (ISIN). An ISIN uniquely identifies a security, such as stocks, bonds or derivatives. It is a 12-character alphanumeric code.
+The `LuhnDotNet` library can be used in combination with the `AlphaNumericToNumeric` method to validate an International Securities Identification Number (ISIN). An ISIN uniquely identifies a security, such as stocks, bonds or derivatives. It is a 12-character alphanumeric code.
 
-The `ConvertAlphaNumericToNumeric` method is used to convert the alphanumeric ISIN to a numeric string, where each letter in the input string is replaced by its decimal ASCII value minus 55. This numeric string can then be validated using the `Luhn.IsValid` method.
+The `AlphaNumericToNumeric` method is used to convert the alphanumeric ISIN to a numeric string, where each letter in the input string is replaced by its decimal ASCII value minus 55. This numeric string can then be validated using the `Luhn.IsValid` method.
 
 Here is an example of how to use these methods to validate an ISIN:
 
@@ -231,15 +231,15 @@ namespace Example5
         public static void Main(string[] args)
         {
             string isin = "US0378331005";
-            bool isValid = isin.ConvertAlphaNumericToNumeric().IsValidLuhnNumber();
+            bool isValid = isin.AlphaNumericToNumeric().IsValidLuhnNumber();
             Console.WriteLine($"The ISIN {isin} is valid: {isValid}");
         }
     }
 }
 ```
-## Compute ISIN Check Digit with LuhnDotNet and ConvertAlphaNumericToNumeric
+## Compute ISIN Check Digit with LuhnDotNet and AlphaNumericToNumeric
 
-The `LuhnDotNet` library provides the `ComputeLuhnCheckDigit` method which can be used to compute the check digit of a numeric string according to the Luhn algorithm. When dealing with an International Securities Identification Number (ISIN), which is a 12-character alphanumeric code, we first need to convert the alphanumeric ISIN to a numeric string. This can be achieved using the `ConvertAlphaNumericToNumeric` method.
+The `LuhnDotNet` library provides the `ComputeLuhnCheckDigit` method which can be used to compute the check digit of a numeric string according to the Luhn algorithm. When dealing with an International Securities Identification Number (ISIN), which is a 12-character alphanumeric code, we first need to convert the alphanumeric ISIN to a numeric string. This can be achieved using the `AlphaNumericToNumeric` method.
 
 Here is an example of how to compute the check digit of an ISIN:
 
@@ -254,7 +254,7 @@ namespace Example6
         public static void Main(string[] args)
         {
             string isinWithoutCheckDigit = "US037833100";
-            byte checkDigit = isinWithoutCheckDigit.ConvertAlphaNumericToNumeric().ComputeLuhnCheckDigit();
+            byte checkDigit = isinWithoutCheckDigit.AlphaNumericToNumeric().ComputeLuhnCheckDigit();
             Console.WriteLine($"The check digit for ISIN {isinWithoutCheckDigit} is: {checkDigit}");
         }
     }

src/Luhn.cs

@@ -246,7 +246,7 @@ public static bool IsValidLuhnCheckDigit(this byte checkDigit, string number)
         /// This method iterates over each character in the input string. If the character is a letter, it is replaced
         /// by its decimal ASCII value minus 55. If the character is a digit, it is left unchanged.
         /// </remarks>
-        public static string ConvertAlphaNumericToNumeric(this string alphaNumeric)
+        public static string AlphaNumericToNumeric(this string alphaNumeric)
 #if NET8_0_OR_GREATER
         {
             Span<char> result = stackalloc char[alphaNumeric.Length * 2];

tests/LuhnTest.cs

@@ -268,7 +268,7 @@ public void LuhnCheckDigitValidationExceptionTest(string invalidNumber, byte che
         }
 
         /// <summary>
-        /// Test data for ConvertAlphaNumericToNumeric method.
+        /// Test data for AlphaNumericToNumeric method.
         /// </summary>
         public static IEnumerable<object[]> ConvertAlphaNumericToNumericData =>
             new List<object[]>
@@ -282,33 +282,33 @@ public void LuhnCheckDigitValidationExceptionTest(string invalidNumber, byte che
             };
 
         /// <summary>
-        /// Tests the ConvertAlphaNumericToNumeric method.
+        /// Tests the AlphaNumericToNumeric method.
         /// </summary>
         /// <param name="input">Input string</param>
         /// <param name="expected">Expected output</param>
         [Theory(DisplayName = "Converts an alphanumeric string to a numeric string")]
         [MemberData(nameof(ConvertAlphaNumericToNumericData), MemberType = typeof(LuhnTest))]
         public void ConvertAlphaNumericToNumeric_ShouldReturnExpectedResult(string input, string expected)
         {
-            Assert.Equal(expected, input.ConvertAlphaNumericToNumeric());
+            Assert.Equal(expected, input.AlphaNumericToNumeric());
         }
 
         /// <summary>
-        /// Tests the ConvertAlphaNumericToNumeric method with invalid input.
+        /// Tests the AlphaNumericToNumeric method with invalid input.
         /// </summary>
         /// <remarks>
-        /// This test checks if the ConvertAlphaNumericToNumeric method throws an ArgumentException when it is given an
+        /// This test checks if the AlphaNumericToNumeric method throws an ArgumentException when it is given an
         /// invalid input string that contains non-alphanumeric characters. The test uses the Assert. Throws method from
         /// xUnit to check if the expected exception is thrown.
         /// </remarks>
         [Fact(DisplayName = "Converts an invalid alphanumeric string to a numeric string to throw an exception")]
         public void ConvertAlphaNumericToNumeric_InvalidInput_ThrowsArgumentException()
         {
-            Assert.Throws<ArgumentException>(()=> "!@#$%^&*()".ConvertAlphaNumericToNumeric());
+            Assert.Throws<ArgumentException>(()=> "!@#$%^&*()".AlphaNumericToNumeric());
         }
 
         /// <summary>
-        /// Test data for IsValid method in combination with ConvertAlphaNumericToNumeric.
+        /// Test data for IsValid method in combination with AlphaNumericToNumeric.
         /// </summary>
         public static IEnumerable<object[]> IsValidWithConvertData =>
             new List<object[]>
@@ -322,20 +322,20 @@ public void ConvertAlphaNumericToNumeric_InvalidInput_ThrowsArgumentException()
             };
 
         /// <summary>
-        /// Tests the IsValid method in combination with ConvertAlphaNumericToNumeric.
+        /// Tests the IsValid method in combination with AlphaNumericToNumeric.
         /// </summary>
         /// <param name="input">Input string</param>
         /// <param name="expected">Expected output</param>
         [Theory(DisplayName = "Validates a numeric string converted from an alphanumeric string")]
         [MemberData(nameof(IsValidWithConvertData), MemberType = typeof(LuhnTest))]
         public void IsValidWithConvertTest(string input, bool expected)
         {
-            Assert.Equal(expected, input.ConvertAlphaNumericToNumeric().IsValidLuhnNumber());
-            Assert.Equal(expected, input.ConvertAlphaNumericToNumeric().AsSpan().IsValidLuhnNumber());
+            Assert.Equal(expected, input.AlphaNumericToNumeric().IsValidLuhnNumber());
+            Assert.Equal(expected, input.AlphaNumericToNumeric().AsSpan().IsValidLuhnNumber());
         }
 
         /// <summary>
-        /// Provides test data for the ComputeLuhnCheckDigit method in combination with ConvertAlphaNumericToNumeric.
+        /// Provides test data for the ComputeLuhnCheckDigit method in combination with AlphaNumericToNumeric.
         /// </summary>
         /// <remarks>
         /// This method returns a collection of object arrays, where each array contains an input string and the
@@ -353,14 +353,14 @@ public void IsValidWithConvertTest(string input, bool expected)
             };
 
         /// <summary>
-        /// Tests the ComputeLuhnCheckDigit method in combination with ConvertAlphaNumericToNumeric.
+        /// Tests the ComputeLuhnCheckDigit method in combination with AlphaNumericToNumeric.
         /// </summary>
         /// <param name="input">Input string</param>
         /// <param name="expected">Expected output</param>
         /// <remarks>
         /// This test checks if the ComputeLuhnCheckDigit method returns the expected check digit when it is given an
         /// alphanumeric string that represents a part of an ISIN without the check digit. The input string is first
-        /// converted to a numeric string using the ConvertAlphaNumericToNumeric method, and then the
+        /// converted to a numeric string using the AlphaNumericToNumeric method, and then the
         /// ComputeLuhnCheckDigit method is called with this numeric string. The test uses the Assert. Equal method from
         /// xUnit to check if the actual check digit matches the expected check digit.
         /// </remarks>
@@ -370,8 +370,8 @@ public void ComputeLuhnCheckDigit_WithConvertAlphaNumericToNumeric_ReturnsExpect
             string input,
             byte expected)
         {
-            Assert.Equal(expected, input.ConvertAlphaNumericToNumeric().ComputeLuhnCheckDigit());
-            Assert.Equal(expected, input.ConvertAlphaNumericToNumeric().AsSpan().ComputeLuhnCheckDigit());
+            Assert.Equal(expected, input.AlphaNumericToNumeric().ComputeLuhnCheckDigit());
+            Assert.Equal(expected, input.AlphaNumericToNumeric().AsSpan().ComputeLuhnCheckDigit());
         }
     }
 }