Add validation generator script and validate function

Signed-off-by: Tushar Goel <tushar.goel.dav@gmail.com>

Author: TG1999

etc/scripts/generate_validators.py

@@ -0,0 +1,314 @@
+# Generate a simple script based on provided list for package types
+
+"""
+{
+  "$schema": "https://packageurl.org/schemas/purl-type-definition.schema-1.0.json",
+  "$id": "https://packageurl.org/types/pypi-definition.json",
+  "type": "pypi",
+  "type_name": "PyPI",
+  "description": "Python packages",
+  "repository": {
+    "use_repository": true,
+    "default_repository_url": "https://pypi.org",
+    "note": "Previously https://pypi.python.org"
+  },
+  "namespace_definition": {
+    "requirement": "prohibited",
+    "note": "there is no namespace"
+  },
+  "name_definition": {
+    "native_name": "name",
+    "case_sensitive": false,
+    "normalization_rules": [
+      "Replace underscore _ with dash -",
+      "Replace dot . with underscore _ when used in distribution (sdist, wheel) names"
+    ],
+    "note": "PyPI treats - and _ as the same character and is not case sensitive. Therefore a PyPI package name must be lowercased and underscore _ replaced with a dash -. Note that PyPI itself is preserving the case of package names. When used in distribution and wheel names, the dot . is replaced with an underscore _"
+  },
+  "version_definition": {
+    "case_sensitive": false,
+    "native_name": "version"
+  },
+  "qualifiers_definition": [
+    {
+      "key": "file_name",
+      "requirement": "optional",
+      "description": "The file_name qualifier selects a particular distribution file (case-sensitive). For naming convention, see the Python Packaging User Guide on source distributions https://packaging.python.org/en/latest/specifications/source-distribution-format/#source-distribution-file-name and on binary distributions https://packaging.python.org/en/latest/specifications/binary-distribution-format/#file-name-convention and the rules for platform compatibility tags https://packaging.python.org/en/latest/specifications/platform-compatibility-tags/"
+    }
+  ],
+  "examples": [
+    "pkg:pypi/django@1.11.1",
+    "pkg:pypi/django@1.11.1?filename=Django-1.11.1.tar.gz",
+    "pkg:pypi/django@1.11.1?filename=Django-1.11.1-py2.py3-none-any.whl",
+    "pkg:pypi/django-allauth@12.23"
+  ]
+}
+"""
+from packageurl import PackageURL
+from pathlib import Path
+import json
+
+HEADER = '''# Copyright (c) the purl authors
+# SPDX-License-Identifier: MIT
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# Visit https://github.com/package-url/packageurl-python for support and
+# download.
+
+from packageurl import PackageURL
+from packageurl import normalize
+from packageurl.contrib.route import Router
+
+"""
+Validate each type according to the PURL spec type definitions
+"""
+
+class TypeValidator:
+    @classmethod
+    def validate(cls, purl: PackageURL, strict=False):
+        if not strict:
+            purl = cls.normalize(purl)
+
+        if cls.namespace_requirement == "prohibited" and purl.namespace:
+            yield f"Namespace is prohibited for purl type: {cls.type!r}"
+        
+        if not cls.namespace_case_sensitive and purl.namespace and purl.namespace.lower() != purl.name:
+            yield f"Namespace is not lowercased for purl type: {cls.type!r}"
+        
+        if not cls.name_case_sensitive and purl.name and purl.name.lower() != purl.name:
+            yield f"Name is not lowercased for purl type: {cls.type!r}"
+
+        if not cls.version_case_sensitive and purl.version and purl.version.lower() != purl.version:
+            yield f"Version is not lowercased for purl type: {cls.type!r}"
+        
+        yield from cls.validate_type(purl)
+    
+    @classmethod
+    def normalize_type(cls, type: str):
+        return type
+     
+    @classmethod
+    def normalize_namespace(cls, namespace: str):
+        return namespace
+    
+    @classmethod
+    def normalize_name(cls, name: str):
+        return name
+
+    @classmethod
+    def normalize_version(cls, version: str):
+        return version
+    
+    @classmethod
+    def normalize_qualifiers(cls, qualifiers: dict):
+        return qualifiers
+    
+    @classmethod
+    def normalize_subpath(cls, subpath: str):
+        return subpath
+
+    @classmethod
+    def normalize(cls, purl: PackageURL):
+        type_norm, namespace_norm, name_norm, version_norm, qualifiers_norm, subpath_norm = normalize(purl.type, 
+            purl.namespace, 
+            purl.name, 
+            purl.version, 
+            purl.qualifiers, 
+            purl.subpath,
+            encode=False,
+        )
+
+        return PackageURL(
+            type = type_norm,
+            namespace = namespace_norm,
+            name = name_norm,
+            version = version_norm,
+            qualifiers = qualifiers_norm,
+            subpath = subpath_norm,
+        )
+
+    @classmethod
+    def validate_type(cls, purl: PackageURL):
+        yield from cls.validate_qualifiers(purl=purl)
+        
+    @classmethod
+    def validate_qualifiers(cls, purl: PackageURL):
+        if not purl.qualifiers:
+            return
+    
+        purl_qualifiers_keys = set(purl.qualifiers.keys())
+        allowed_qualifiers_set = cls.allowed_qualifiers
+
+        disallowed = purl_qualifiers_keys - allowed_qualifiers_set
+        
+        if disallowed:
+            yield (f"Invalid qualifiers found: {', '.join(disallowed)}. "
+                f"Allowed qualifiers are: {', '.join(allowed_qualifiers_set)}"
+            )
+'''
+
+def validate_qualifiers(allowed_qualifiers, purl: PackageURL):
+    if not purl.qualifiers:
+        return True
+    
+    purl_qualifiers_keys = set(purl.qualifiers.keys())
+    allowed_qualifiers_set = set(allowed_qualifiers)
+
+    disallowed = purl_qualifiers_keys - allowed_qualifiers_set
+    
+    if disallowed:
+        yield (f"Invalid qualifiers found: {', '.join(disallowed)}. "
+            f"Allowed qualifiers are: {', '.join(allowed_qualifiers_set)}"
+        )
+
+
+
+TEMPLATE = """
+class {class_name}({validator_class}):
+    type = "{type}"
+    type_name = "{type_name}"
+    description = '''{description}'''
+    use_repository = {use_repository}
+    default_repository_url = "{default_repository_url}"
+    namespace_requirement = "{namespace_requirement}"
+    allowed_qualifiers = {allowed_qualifiers}
+    namespace_case_sensitive = {namespace_case_sensitive}
+    name_case_sensitive = {name_case_sensitive}
+    version_case_sensitive = {version_case_sensitive}
+    purl_pattern = "{purl_pattern}"
+"""
+
+TEMPLATE_NAME_RULES = '''
+    @override
+    @classmethod
+    def normalize_name(cls, name: str):
+        """
+        Normalize name according to type rules
+        {rules}
+        """
+        raise NotImplementedError()
+'''
+
+def generate_validators():
+    """
+    Generate validators for all package types defined in the packageurl specification.
+    """
+
+    base_dir = Path(__file__).parent.parent.parent
+
+    types_dir = base_dir / "spec" / "types"
+
+    script_parts = [HEADER]
+
+    validators_by_type = {}
+
+    for type in sorted(types_dir.glob("*.json")):
+        type_def = json.loads(type.read_text())
+
+        _type = type_def["type"]
+        standard_validator_class = "TypeValidator"
+
+        class_prefix = _type.capitalize()
+        class_name = f"{class_prefix}{standard_validator_class}"
+        validators_by_type[_type] = class_name
+        name_normalization_rules=type_def["name_definition"].get("normalization_rules") or []
+        allowed_qualifiers = [defintion.get("key") for defintion in type_def.get("qualifiers_definition") or []]
+        namespace_case_sensitive = type_def["namespace_definition"].get("case_sensitive") or False
+        name_case_sensitive = type_def["name_definition"].get("case_sensitive") or False
+        version_definition = type_def.get("version_definition") or {}
+        version_case_sensitive = version_definition.get("case_sensitive") or False
+        repository = type_def.get("repository")
+        use_repository_url = repository.get("use_repository") or False 
+
+        if use_repository_url and "repsitory_url" not in allowed_qualifiers:
+            allowed_qualifiers.append("repository_url")
+
+        allowed_qualifiers = set(allowed_qualifiers)
+
+        type_validator = TEMPLATE.format(**dict(
+            class_name=class_name,
+            validator_class=standard_validator_class,
+            type=_type,
+            type_name=type_def["type_name"],
+            description=type_def["description"],
+            use_repository=type_def["repository"]["use_repository"],
+            default_repository_url=type_def["repository"].get("default_repository_url") or "",
+            namespace_requirement=type_def["namespace_definition"]["requirement"],
+            name_normalization_rules=name_normalization_rules,
+            allowed_qualifiers=allowed_qualifiers or [],
+            namespace_case_sensitive=namespace_case_sensitive,
+            name_case_sensitive=name_case_sensitive,
+            version_case_sensitive=version_case_sensitive,
+            purl_pattern=f"pkg:{_type}/.*"
+        ))
+
+        script_parts.append(type_validator)
+
+        # if name_normalization_rules:
+        #     name_overrides = get_name_norm_rules(name_normalization_rules)
+        #     script_parts.append(name_overrides)
+    
+    script_parts.append(generate_validators_by_type(validators_by_type=validators_by_type))
+    script_parts.append(attach_router(validators_by_type.values()))
+
+    validate_script = base_dir / "src" / "packageurl" / "validate.py"
+
+    validate_script.write_text("\n".join(script_parts))
+
+
+def get_name_norm_rules(name_normalization_rules):
+    rules = "\n".join(name_normalization_rules)
+    return TEMPLATE_NAME_RULES.format(rules=rules)
+
+
+def generate_validators_by_type(validators_by_type):
+    """
+    Return a python snippet that maps a type to it's TypeValidator class
+    """
+    snippets = []
+    for type, class_name in validators_by_type.items():
+        snippet = f"    {type!r} : {class_name},"
+        snippets.append(snippet)
+
+    snippets = "\n".join(snippets)
+    start = "VALIDATORS_BY_TYPE = {"
+    end = "}"
+    return f"{start}\n{snippets}\n{end}"
+
+def attach_router(classes):
+    snippets = []
+    for class_name in classes:
+        snippet = f"    {class_name},"
+        snippets.append(snippet)
+    snippets = "\n".join(snippets)
+    start = "PACKAGE_REGISTRY = [ \n"
+    end = "\n   ]"
+    classes = f"{start}{snippets}{end}"
+    router_code = '''
+validate_router = Router()
+
+for pkg_class in PACKAGE_REGISTRY:
+    validate_router.append(pattern=pkg_class.purl_pattern, endpoint=pkg_class.validate)
+    '''
+    return f"{classes}{router_code}"
+
+
+if __name__ == "__main__":
+    generate_validators()

spec

@@ -37,6 +37,9 @@
 from urllib.parse import unquote as _percent_unquote
 from urllib.parse import urlsplit as _urlsplit
 
+from packageurl.contrib.route import NoRouteAvailable
+from packageurl.validate import validate_router
+
 if TYPE_CHECKING:
     from collections.abc import Callable
     from collections.abc import Iterable
@@ -470,39 +473,16 @@ def to_string(self, encode: bool | None = True) -> str:
 
         return "".join(purl)
 
-
-    @classmethod
-    def validate_alpm(cls):
-        """Type-specific validation for ALPM PURLs."""
-        if cls.namespace.lower() != cls.namespace:
-            return False, "Namespace must be lowercase."
-        if cls.name.lower() != cls.name:
-            return False, "Package name must be lowercase."
-        if not re.match(r"^[0-9]*:?[\w\.\+\-]+$", cls.version):
-            return False, f"Invalid version format '{cls.version}'."
-
-        if cls.qualifiers:
-            for key in cls.qualifiers:
-                if key != "arch":
-                    return False, f"Unknown qualifier '{key}', only 'arch' is allowed."
-                if not cls.qualifiers[key]:
-                    return False, "Qualifier 'arch' cannot be empty."
-
-
-    @classmethod
-    def validate(cls):
+    def validate(self) -> list[str]:
         """
-        Main validation function.
-        Runs basic validation first, then dispatches to type-specific validators.
-        Yields error messages only.
+        Validate this PackageURL object and return a list of validation error messages.
         """
-        yield from cls.validate_basic()
-
-        validator_by_type: dict[str, Callable[[str], Iterable[str]]] = {
-            "alpm": cls.validate_alpm,
-        }
-
-        yield from validator_by_type()
+        if self:
+            try:
+                messages = list(validate_router.process(self))
+                return messages
+            except NoRouteAvailable:
+                return [f"Given type: {self.type} can not be validated"]
 
     @classmethod
     def from_string(cls, purl: str) -> Self: