refactor: rename alphanumeric function

src/SablierV2NFTDescriptor.sol

@@ -303,8 +303,8 @@ contract SablierV2NFTDescriptor is ISablierV2NFTDescriptor {
     }
 
     /// @notice Checks whether the provided string contains only alphanumeric characters and spaces.
-    /// @dev Note that this returns true for empty strings, but it is not a security concern.
-    function isAlphanumeric(string memory str) internal pure returns (bool) {
+    /// @dev Note that this returns true for empty strings.
+    function isAlphanumericWithSpaces(string memory str) internal pure returns (bool) {
         // Convert the string to bytes to iterate over its characters.
         bytes memory b = bytes(str);
 
@@ -368,8 +368,8 @@ contract SablierV2NFTDescriptor is ISablierV2NFTDescriptor {
         if (bytes(symbol).length > 30) {
             return "Long Symbol";
         } else {
-            if (!isAlphanumeric(symbol)) {
-                return "Non-Alphanumeric Symbol";
+            if (!isAlphanumericWithSpaces(symbol)) {
+                return "Unsupported Symbol";
             }
             return symbol;
         }

test/integration/concrete/nft-descriptor/is-alphanumeric-with-spaces/isAlphanumericWithSpaces.t.sol

@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity >=0.8.22 <0.9.0;
+
+import { NFTDescriptor_Integration_Shared_Test } from "../../../shared/nft-descriptor/NFTDescriptor.t.sol";
+
+contract IsAlphanumericWithSpaces_Integration_Concrete_Test is NFTDescriptor_Integration_Shared_Test {
+    function test_IsAlphanumericWithSpaces_EmptyString() external view {
+        string memory symbol = "";
+        bool result = nftDescriptorMock.isAlphanumericWithSpaces_(symbol);
+        assertTrue(result, "isAlphanumericWithSpaces");
+    }
+
+    modifier whenNotEmptyString() {
+        _;
+    }
+
+    function test_IsAlphanumericWithSpaces_ContainsUnsupportedCharacters() external view whenNotEmptyString {
+        string memory symbol = "<foo/>";
+        bool result = nftDescriptorMock.isAlphanumericWithSpaces_(symbol);
+        assertFalse(result, "isAlphanumericWithSpaces");
+
+        symbol = "foo/";
+        result = nftDescriptorMock.isAlphanumericWithSpaces_(symbol);
+        assertFalse(result, "isAlphanumericWithSpaces");
+
+        symbol = "foo\\";
+        result = nftDescriptorMock.isAlphanumericWithSpaces_(symbol);
+        assertFalse(result, "isAlphanumericWithSpaces");
+
+        symbol = "foo%";
+        result = nftDescriptorMock.isAlphanumericWithSpaces_(symbol);
+        assertFalse(result, "isAlphanumericWithSpaces");
+
+        symbol = "foo&";
+        result = nftDescriptorMock.isAlphanumericWithSpaces_(symbol);
+        assertFalse(result, "isAlphanumericWithSpaces");
+
+        symbol = "foo(";
+        result = nftDescriptorMock.isAlphanumericWithSpaces_(symbol);
+        assertFalse(result, "isAlphanumericWithSpaces");
+
+        symbol = "foo)";
+        result = nftDescriptorMock.isAlphanumericWithSpaces_(symbol);
+        assertFalse(result, "isAlphanumericWithSpaces");
+
+        symbol = "foo\"";
+        result = nftDescriptorMock.isAlphanumericWithSpaces_(symbol);
+        assertFalse(result, "isAlphanumericWithSpaces");
+
+        symbol = "foo'";
+        result = nftDescriptorMock.isAlphanumericWithSpaces_(symbol);
+        assertFalse(result, "isAlphanumericWithSpaces");
+
+        symbol = "foo`";
+        result = nftDescriptorMock.isAlphanumericWithSpaces_(symbol);
+        assertFalse(result, "isAlphanumericWithSpaces");
+
+        symbol = "foo;";
+        result = nftDescriptorMock.isAlphanumericWithSpaces_(symbol);
+        assertFalse(result, "isAlphanumericWithSpaces");
+
+        symbol = "foo%20"; // URL-encoded empty space
+        result = nftDescriptorMock.isAlphanumericWithSpaces_(symbol);
+        assertFalse(result, "isAlphanumericWithSpaces");
+    }
+
+    modifier whenOnlySupportedCharacters() {
+        _;
+    }
+
+    function test_IsAlphanumericWithSpaces() external view whenNotEmptyString whenOnlySupportedCharacters {
+        string memory symbol = "foo";
+        bool result = nftDescriptorMock.isAlphanumericWithSpaces_(symbol);
+        assertTrue(result, "isAlphanumericWithSpaces");
+
+        symbol = "Foo";
+        result = nftDescriptorMock.isAlphanumericWithSpaces_(symbol);
+        assertTrue(result, "isAlphanumericWithSpaces");
+
+        symbol = "Foo ";
+        result = nftDescriptorMock.isAlphanumericWithSpaces_(symbol);
+        assertTrue(result, "isAlphanumericWithSpaces");
+
+        symbol = "Foo Bar";
+        result = nftDescriptorMock.isAlphanumericWithSpaces_(symbol);
+        assertTrue(result, "isAlphanumericWithSpaces");
+
+        symbol = "  ";
+        result = nftDescriptorMock.isAlphanumericWithSpaces_(symbol);
+        assertTrue(result, "isAlphanumericWithSpaces");
+
+        symbol = "foo01234";
+        result = nftDescriptorMock.isAlphanumericWithSpaces_(symbol);
+        assertTrue(result, "isAlphanumericWithSpaces");
+
+        symbol = "123456789";
+        result = nftDescriptorMock.isAlphanumericWithSpaces_(symbol);
+        assertTrue(result, "isAlphanumericWithSpaces");
+    }
+}

test/integration/concrete/nft-descriptor/is-alphanumeric/isAlphanumeric.tree → test/integration/concrete/nft-descriptor/is-alphanumeric-with-spaces/isAlphanumericWithSpaces.tree

@@ -1,8 +1,8 @@
-isAlphanumeric.t.sol
+isAlphanumericWithSpaces.t.sol
 ├── when the symbol is an empty string
 │  └── it should return true
 └── when the symbol is not an empty string
-   ├── given the symbol does not contain only alphanumeric characters
+   ├── given the symbol contain unsupported characters
    │  └── it should return false
-   └── given the symbol contains only alphanumeric characters
+   └── given the symbol contains only supported characters
       └── it should return true

test/integration/concrete/nft-descriptor/safe-asset-symbol/safeAssetSymbol.t.sol

@@ -51,7 +51,7 @@ contract SafeAssetSymbol_Integration_Concrete_Test is NFTDescriptor_Integration_
     function test_SafeAssetSymbol_NonAlphanumeric() external whenERC20Contract givenSymbolString givenSymbolNotLong {
         ERC20Mock asset = new ERC20Mock({ name: "Token", symbol: "<svg/onload=alert(\"xss\")>" });
         string memory actualSymbol = nftDescriptorMock.safeAssetSymbol_(address(asset));
-        string memory expectedSymbol = "Non-Alphanumeric Symbol";
+        string memory expectedSymbol = "Unsupported Symbol";
         assertEq(actualSymbol, expectedSymbol, "symbol");
     }
 

test/integration/fuzz/nft-descriptor/isAlphanumeric.t.sol → test/integration/fuzz/nft-descriptor/isAlphanumericWithSpaces.t.sol

@@ -3,7 +3,7 @@ pragma solidity >=0.8.22 <0.9.0;
 
 import { NFTDescriptor_Integration_Shared_Test } from "../../shared/nft-descriptor/NFTDescriptor.t.sol";
 
-contract IsAlphanumeric_Integration_Fuzz_Test is NFTDescriptor_Integration_Shared_Test {
+contract IsAlphanumericWithSpaces_Integration_Fuzz_Test is NFTDescriptor_Integration_Shared_Test {
     bytes1 internal constant SPACE = 0x20; // ASCII 32
     bytes1 internal constant ZERO = 0x30; // ASCII 48
     bytes1 internal constant NINE = 0x39; // ASCII 57
@@ -21,22 +21,22 @@ contract IsAlphanumeric_Integration_Fuzz_Test is NFTDescriptor_Integration_Share
     /// - String with only alphanumerical characters
     /// - String with only non-alphanumerical characters
     /// - String with both alphanumerical and non-alphanumerical characters
-    function testFuzz_IsAlphanumeric(string memory symbol) external view whenNotEmptyString {
+    function testFuzz_IsAlphanumericWithSpaces(string memory symbol) external view whenNotEmptyString {
         bytes memory b = bytes(symbol);
         uint256 length = b.length;
         bool expectedResult = true;
         for (uint256 i = 0; i < length; ++i) {
             bytes1 char = b[i];
-            if (!isAlphanumericChar(char)) {
+            if (!isAlphanumericOrSpaceChar(char)) {
                 expectedResult = false;
                 break;
             }
         }
-        bool actualResult = nftDescriptorMock.isAlphanumeric_(symbol);
-        assertEq(actualResult, expectedResult, "isAlphanumeric");
+        bool actualResult = nftDescriptorMock.isAlphanumericWithSpaces_(symbol);
+        assertEq(actualResult, expectedResult, "isAlphanumericWithSpaces");
     }
 
-    function isAlphanumericChar(bytes1 char) internal pure returns (bool) {
+    function isAlphanumericOrSpaceChar(bytes1 char) internal pure returns (bool) {
         bool isSpace = char == SPACE;
         bool isDigit = char >= ZERO && char <= NINE;
         bool isUppercaseLetter = char >= A && char <= Z;

test/mocks/NFTDescriptorMock.sol

@@ -78,8 +78,8 @@ contract NFTDescriptorMock is SablierV2NFTDescriptor {
         return SVGElements.hourglass(status);
     }
 
-    function isAlphanumeric_(string memory symbol) external pure returns (bool) {
-        return isAlphanumeric(symbol);
+    function isAlphanumericWithSpaces_(string memory symbol) external pure returns (bool) {
+        return isAlphanumericWithSpaces(symbol);
     }
 
     function mapSymbol_(IERC721Metadata nft) external view returns (string memory) {