updates namespace regex to fit test strings

Author: ahouseholder

data/schema/v2/Decision_Point_Value_Selection-2-0-0.schema.json

@@ -13,7 +13,7 @@
           ],
           "maxLength": 1000,
           "minLength": 3,
-          "pattern": "^(?=.{3,1000}$)(x_)?[a-z0-9]{3}([/.-]?[a-z0-9]+){0,997}$$",
+          "pattern": "^(?=.{3,1000}$)((x_(?!.*[.-]{2,})[a-z][a-z0-9]{2,}(?:[.-][a-z0-9]+)*|(?!.*[.-]{2,})[a-z][a-z0-9]{2,}(?:[.-][a-z0-9]+)*))((/((([A-Za-z]{2,3}(-[A-Za-z]{3}(-[A-Za-z]{3}){0,2})?|[A-Za-z]{4,8})(-[A-Za-z]{4})?(-([A-Za-z]{2}|[0-9]{3}))?(-([A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*(-[A-WY-Za-wy-z0-9](-[A-Za-z0-9]{2,8})+)*(-[Xx](-[A-Za-z0-9]{1,8})+)?|[Xx](-[A-Za-z0-9]{1,8})+|[Ii]-[Dd][Ee][Ff][Aa][Uu][Ll][Tt]|[Ii]-[Mm][Ii][Nn][Gg][Oo]))/|//)(?!.*[.-]{2,})[a-zA-Z][a-zA-Z0-9]*(?:[.-][a-zA-Z0-9]+)*(?:/(?!.*[.-]{2,})[a-zA-Z][a-zA-Z0-9]*(?:[.-][a-zA-Z0-9]+)*)*)?$",
           "title": "Namespace",
           "type": "string"
         },

src/ssvc/namespaces.py

@@ -29,69 +29,83 @@
 
 from pydantic import Field
 
-X_PFX = "x_"
-"""The prefix for extension namespaces. Extension namespaces must start with this prefix."""
-
 MIN_NS_LENGTH = 3
 MAX_NS_LENGTH = 1000
 NS_LENGTH_INTERVAL = MAX_NS_LENGTH - MIN_NS_LENGTH
 
-
 # from https://docs.oasis-open.org/csaf/csaf/v2.0/os/csaf-v2.0-os.html
 BCP_47_PATTERN = r"(([A-Za-z]{2,3}(-[A-Za-z]{3}(-[A-Za-z]{3}){0,2})?|[A-Za-z]{4,8})(-[A-Za-z]{4})?(-([A-Za-z]{2}|[0-9]{3}))?(-([A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*(-[A-WY-Za-wy-z0-9](-[A-Za-z0-9]{2,8})+)*(-[Xx](-[A-Za-z0-9]{1,8})+)?|[Xx](-[A-Za-z0-9]{1,8})+|[Ii]-[Dd][Ee][Ff][Aa][Uu][Ll][Tt]|[Ii]-[Mm][Ii][Nn][Gg][Oo])"
+"""A regular expression pattern for BCP-47 language tags."""
 
 LENGTH_CHECK_PATTERN = rf"(?=.{{{MIN_NS_LENGTH},{MAX_NS_LENGTH}}}$)"
 """Ensures the string is between MIN_NS_LENGTH and MAX_NS_LENGTH characters long."""
 
 # Base namespace part (before any extensions) allows . and - with restrictions
 BASE_PATTERN = (
     r"(?!.*[.-]{2,})"  # no consecutive separators
-    r"[a-z][a-z0-9]{2,}"  # first part starts with a letter, followed by one or more alphanumeric characters
+    r"[a-z][a-z0-9]{2,}"  # first part starts with a letter, followed by three or more alphanumeric characters
     r"(?:[.-][a-z0-9]+)*"  # remaining parts can have alphanumeric characters and single . or - separators
 )
+"""The base pattern for namespaces, which must start with a letter and contain at least 3 alphanumeric characters."""
 
 X_PFX = "x_"
+"""The prefix for extension namespaces. Extension namespaces must start with this prefix."""
+
 EXPERIMENTAL_BASE = rf"{X_PFX}{BASE_PATTERN}"
+f"""The base pattern for experimental namespaces, which must start with the {X_PFX} prefix, 
+followed by a string matching the base pattern."""
+
 BASE_NS_PATTERN = rf"({EXPERIMENTAL_BASE}|{BASE_PATTERN})"
+"""The complete base namespace pattern, which allows for experimental namespaces."""
 
 # Extension segment pattern (alphanumeric + limited punctuation, no consecutive punctuation, ends with alphanumeric)
 EXT_SEGMENT_PATTERN = (
     r"(?!.*[.-]{2,})"  # no consecutive separators
-    r"[a-zA-Z0-9]+"  # first part starts with a letter, followed by one or more alphanumeric characters
+    r"[a-zA-Z][a-zA-Z0-9]*"  # first part starts with a letter, followed by one or more alphanumeric characters
     r"(?:[.-][a-zA-Z0-9]+)*"  # remaining parts can have alphanumeric characters and single ., -, / separators
 )
+"""The pattern for extension segments in namespaces, which must start with a letter and contain alphanumeric characters or
+limited punctuation characters (., -), with no consecutive punctuation characters allowed."""
 
 # Language extension pattern (BCP-47 or empty for //)
-LANG_EXT_PATTERN = rf"(/({BCP_47_PATTERN})|/)"
+LANG_EXT_PATTERN = rf"(/({BCP_47_PATTERN})/|//)"
+"""The pattern for the first extension segment, which must be either a valid BCP-47 tag or empty (//)."""
 
 # Subsequent extension segments
-SUBSEQUENT_EXT_PATTERN = rf"(/{EXT_SEGMENT_PATTERN})*"
+SUBSEQUENT_EXT_PATTERN = rf"{EXT_SEGMENT_PATTERN}(?:/{EXT_SEGMENT_PATTERN})*"
+"""The pattern for subsequent extension segments, which must follow the rules for extension segments, delimited by slashes (/)."""
 
 # Complete pattern with length validation
 NS_PATTERN = re.compile(
-    rf"^{LENGTH_CHECK_PATTERN}{BASE_NS_PATTERN}({LANG_EXT_PATTERN}{SUBSEQUENT_EXT_PATTERN})?$"
+    rf"^{LENGTH_CHECK_PATTERN}({BASE_NS_PATTERN})({LANG_EXT_PATTERN}{SUBSEQUENT_EXT_PATTERN})?$"
 )
-f"""The regular expression pattern for validating namespaces.
+f"""The full regular expression pattern for validating namespaces.
+
+!!! note "Length Requirements"
 
-!!! note "Namespace Validation Rules"
+    - Namespaces must be between {MIN_NS_LENGTH} and {MAX_NS_LENGTH} characters long.
 
-    Namespace values must 
+!!! note "Base Namespace Requirements"
+    
+    - Must start with a lowercase letter
+    - Must contain at least 3 total characters in the base part (after the optional experimental/private prefix)
+    - Must contain only lowercase letters, numbers, dots (`.`), and hyphens (`-`)
+    - Must not contain consecutive dots or hyphens (no `..`, `--`, `.-`, `-.`, `---`, etc.)
+    - May optionally start with the experimental/private prefix `{X_PFX}`.
+    
+!!! note "Extension Requirements (Optional)"
     
-    - be {MIN_NS_LENGTH}-{MAX_NS_LENGTH} characters long
-    - optionally start with the experimental/private prefix `{X_PFX}`
-    - after the optional experimental/private prefix, they must:
-        - start with a letter
-        - contain at least 3 alphanumeric characters (longer is permitted)
-        - contain only lowercase alphanumeric characters and limited punctuation characters (`.`, `-`)
-    - extensions are supported and optional, and are delineated by slashes (`/`)
-    - more than one extension segment is allowed, however:
-        - the first extension segment, if present, is reserved for a BCP-47 language tag, otherwise it must be empty
-        - if no BCP-47 tag is present, the first extension segment must be empty (i.e., `//`)
-        - double slashes (`//`) are *only* permitted in the *first segment* to indicate no BCP-47 tag
-    - beyond the first extension segment, subsequent segments must:
-        - contain only alphanumeric characters and limited punctuation characters (`.`, `-`)
-        - have only one punctuation character in a row (no double dashes or dots)
-        - end with an alphanumeric character
+    - Extensions are optional
+    - Extensions must be delineated by slashes (`/`)
+    - If any extension segments are present, the following rules apply:
+    - The first extension segment, must be a valid BCP-47 language tag or empty (i.e., `//`).
+    - Subsequent extension segments:
+        - must start with a letter (upper or lowercase)
+        - may contain letters, numbers, dots (`.`), and hyphens (`-`)
+        - must not start or end with a dot or hyphen
+        - must not contain consecutive dots or hyphens (no `..`, `--`, `.-`, `-.`, `---`, etc.)
+        - are separated by single forward slashes (`/`)
+    - multiple extension segments are allowed
     
 """
 

src/test/test_mixins.py

@@ -114,7 +114,7 @@ def test_namespaced_create(self):
         # custom namespaces are allowed as long as they start with x_
         for _ in range(100):
             # we're just fuzzing some random strings here
-            ns = f"x_{randint(1000,1000000)}"
+            ns = f"x_a{randint(1000,1000000)}"
             obj = _Namespaced(namespace=ns)
             self.assertEqual(obj.namespace, ns)
 

src/test/test_namespaces.py

@@ -34,8 +34,9 @@ def test_ns_pattern(self):
             "foo",
             "foo.bar",
             "foo.bar.baz",
-            "foo/bar/baz/quux",
-            "foo.bar/baz.quux",
+            "foo/jp-JP/bar.baz/quux",
+            "foo//bar/baz/quux",
+            "foo.bar//baz.quux",
         ]
         should_match.extend([f"x_{ns}" for ns in should_match])
 

src/ssvc/test/test_namespaces_pattern.py src/test/test_namespaces_pattern.pysrc/ssvc/test/test_namespaces_pattern.py renamed to src/test/test_namespaces_pattern.py

@@ -47,6 +47,7 @@ def setUp(self):
             "x_custom//extension",  # double slash is okay when it's the first segment
             "ssvc/de-DE/reference-arch-1",  # valid BCP-47 tag with dashes
             "x_test/pl-PL/foo/bar/baz/quux",  # valid BCP-47 tag and multiple segments
+            "foo.bar//baz.quux",  # valid namespace with x_ prefix and mixed segments
         ]
         self.expect_fail = [
             "999",  # invalid namespace, numeric only