refactor: extract shared lifecycle parsing and version parsing utilities (#303)

* refactor: extract shared lifecycle parsing and version parsing utilities

- Add LifecycleData.from_dict() classmethod to centralize lifecycle
  parsing from YAML dicts, replacing duplicated inline blocks in
  requirements_model_generator.py and svcs_model_generator.py
- Add Utils.parse_version() to centralize version string parsing,
  replacing duplicated __parse_req_version and __parse_svc_version
  private methods
- Remove unused LIFECYCLESTATE, InvalidVersion, and Version imports
  from both generators
- Add 4 unit tests for LifecycleData.from_dict() (TDD)

Signed-off-by: jimisola <jimisola@jimisola.com>

* style: fix import ordering in utils.py

Signed-off-by: jimisola <jimisola@jimisola.com>

---------

Signed-off-by: jimisola <jimisola@jimisola.com>
Co-authored-by: Jimisola Laursen <jimisola.laursen@resurs.se>

Author: jimisola

src/reqstool/common/dataclasses/lifecycle.py

@@ -1,7 +1,10 @@
 # Copyright © LFV
 
+from __future__ import annotations
+
 from dataclasses import dataclass, field
 from enum import Enum, unique
+from typing import Optional
 
 
 @unique
@@ -24,3 +27,12 @@ class LIFECYCLESTATE(Enum):
 class LifecycleData:
     reason: str = field(default=str)
     state: LIFECYCLESTATE = field(default=LIFECYCLESTATE.EFFECTIVE)
+
+    @classmethod
+    def from_dict(cls, data: Optional[dict]) -> LifecycleData:
+        if data is None:
+            return cls(state=LIFECYCLESTATE.EFFECTIVE, reason=None)
+        return cls(
+            state=LIFECYCLESTATE(data["state"]),
+            reason=data.get("reason"),
+        )

src/reqstool/common/utils.py

@@ -11,6 +11,7 @@
 from zipfile import ZipFile
 
 import requests
+from packaging.version import InvalidVersion, Version as PkgVersion
 from requests_file import FileAdapter
 
 from reqstool.common.dataclasses.urn_id import UrnId
@@ -334,6 +335,13 @@ def get_accessible_nodes(graph: Dict[str, List[str]], start_node: str):
 
         return accessible_nodes_dict
 
+    @staticmethod
+    def parse_version(version_str: str, urn_id: UrnId) -> PkgVersion:
+        try:
+            return PkgVersion(version_str)
+        except InvalidVersion as e:
+            raise TypeError(f"Invalid version: {e} for: {urn_id}")
+
 
 class TempDirectoryUtil:
     tmpdir: tempfile.TemporaryDirectory = None

src/reqstool/model_generators/requirements_model_generator.py

@@ -5,12 +5,11 @@
 from enum import Enum, unique
 from typing import Dict, List, Set
 
-from packaging.version import InvalidVersion, Version
 from reqstool_python_decorators.decorators.decorators import Requirements
 from ruamel.yaml import YAML
 
 from reqstool.commands.exit_codes import EXIT_CODE_SYNTAX_VALIDATION_ERROR
-from reqstool.common.dataclasses.lifecycle import LIFECYCLESTATE, LifecycleData
+from reqstool.common.dataclasses.lifecycle import LifecycleData
 from reqstool.common.dataclasses.urn_id import UrnId
 from reqstool.common.utils import Utils
 from reqstool.common.validators.semantic_validator import SemanticValidator
@@ -342,14 +341,6 @@ def __parse_requirements(self, data):  # NOSONAR
                 rationale = req["rationale"] if "rationale" in req else None
                 # Check if implementation is defined, or set it to True
                 implementation = req["implementation"] if "implementation" in req else IMPLEMENTATION.IN_CODE.value
-                # Get lifecycle variables or use defaults
-                if "lifecycle" in req:
-                    lifecycle_state = LIFECYCLESTATE(req["lifecycle"]["state"])
-                    lifecycle_reason = req["lifecycle"]["reason"] if "reason" in req["lifecycle"] else None
-                else:
-                    lifecycle_state = LIFECYCLESTATE.EFFECTIVE
-                    lifecycle_reason = None
-
                 urn_id = UrnId(urn=urn, id=req["id"])
                 req_data = RequirementData(
                     id=urn_id,
@@ -360,17 +351,11 @@ def __parse_requirements(self, data):  # NOSONAR
                     implementation=IMPLEMENTATION(implementation),
                     categories=[CATEGORIES(c) for c in req["categories"]],
                     references=refs_data,
-                    revision=self.__parse_req_version(version=req["revision"], urn_id=urn_id),
-                    lifecycle=LifecycleData(state=lifecycle_state, reason=lifecycle_reason),
+                    revision=Utils.parse_version(version_str=req["revision"], urn_id=urn_id),
+                    lifecycle=LifecycleData.from_dict(req.get("lifecycle")),
                 )
 
                 if req_data.id not in r_reqs:
                     r_reqs[req_data.id] = req_data
 
         return r_reqs
-
-    def __parse_req_version(self, version: str, urn_id: UrnId) -> Version:
-        try:
-            return Version(version)
-        except InvalidVersion as e:
-            raise TypeError(f"Invalid version: {e} for: {urn_id}")

src/reqstool/model_generators/svcs_model_generator.py

@@ -3,11 +3,10 @@
 import sys
 from typing import Dict, Set
 
-from packaging.version import InvalidVersion, Version
 from ruamel.yaml import YAML
 
 from reqstool.commands.exit_codes import EXIT_CODE_SYNTAX_VALIDATION_ERROR
-from reqstool.common.dataclasses.lifecycle import LIFECYCLESTATE, LifecycleData
+from reqstool.common.dataclasses.lifecycle import LifecycleData
 from reqstool.common.dataclasses.urn_id import UrnId
 from reqstool.common.utils import Utils
 from reqstool.common.validators.semantic_validator import SemanticValidator
@@ -52,23 +51,15 @@ def __parse_svcs(self, data) -> dict[UrnId, SVCData]:
         for case in data["cases"]:
             urn_id = UrnId(urn=self.urn, id=case["id"])
 
-            # Get lifecycle variables or use defaults
-            if "lifecycle" in case:
-                lifecycle_state = LIFECYCLESTATE(case["lifecycle"]["state"])
-                lifecycle_reason = case["lifecycle"]["reason"] if "reason" in case["lifecycle"] else None
-            else:
-                lifecycle_state = LIFECYCLESTATE.EFFECTIVE
-                lifecycle_reason = None
-
             svc = SVCData(
                 id=urn_id,
                 requirement_ids=Utils.convert_ids_to_urn_id(ids=case["requirement_ids"], urn=self.urn),
                 title=case["title"],
                 description=case["description"] if "description" in case else None,
                 verification=VERIFICATIONTYPES(case["verification"]),
                 instructions=case["instructions"] if "instructions" in case else None,
-                revision=self.__parse_svc_version(version=case["revision"], urn_id=urn_id),
-                lifecycle=LifecycleData(state=lifecycle_state, reason=lifecycle_reason),
+                revision=Utils.parse_version(version_str=case["revision"], urn_id=urn_id),
+                lifecycle=LifecycleData.from_dict(case.get("lifecycle")),
             )
 
             if svc.id not in r_result:
@@ -120,9 +111,3 @@ def __parse_svc_filters(self, data) -> Dict[str, SVCFilter]:  # NOSONAR
                 r_filters[urn] = svc_filter
 
         return r_filters
-
-    def __parse_svc_version(self, version: str, urn_id: UrnId) -> Version:
-        try:
-            return Version(version)
-        except InvalidVersion as e:
-            raise TypeError(f"Invalid version: {e} for: {urn_id}")

tests/unit/reqstool/common/dataclasses/test_lifecycle.py

@@ -0,0 +1,25 @@
+from reqstool.common.dataclasses.lifecycle import LIFECYCLESTATE, LifecycleData
+
+
+def test_from_dict_with_state_and_reason():
+    result = LifecycleData.from_dict({"state": "deprecated", "reason": "replaced by REQ_002"})
+    assert result.state == LIFECYCLESTATE.DEPRECATED
+    assert result.reason == "replaced by REQ_002"
+
+
+def test_from_dict_with_state_only():
+    result = LifecycleData.from_dict({"state": "effective"})
+    assert result.state == LIFECYCLESTATE.EFFECTIVE
+    assert result.reason is None
+
+
+def test_from_dict_draft_state():
+    result = LifecycleData.from_dict({"state": "draft", "reason": "under review"})
+    assert result.state == LIFECYCLESTATE.DRAFT
+    assert result.reason == "under review"
+
+
+def test_from_dict_none_returns_default():
+    result = LifecycleData.from_dict(None)
+    assert result.state == LIFECYCLESTATE.EFFECTIVE
+    assert result.reason is None