spl-core 7.9.0__tar.gz → 7.11.0__tar.gz

{spl_core-7.9.0 → spl_core-7.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: spl-core
-Version: 7.9.0
+Version: 7.11.0
 Summary: Software Product Line Support for CMake
 License: MIT
 Author: Avengineers
@@ -23,6 +23,7 @@ Requires-Dist: kconfiglib (>=14.1,<15.0)
 Requires-Dist: mlx-traceability (>=10.0,<11.0)
 Requires-Dist: myst-parser (>=0.16)
 Requires-Dist: py-app-dev (>=2.1,<3.0)
+Requires-Dist: py7zr (>=1.0.0,<2.0.0)
 Requires-Dist: pypeline-runner (>=1,<=2)
 Requires-Dist: pypeline-semantic-release (>=0.4.1,<=0.5.0)
 Requires-Dist: sphinx (>=7.3,<8.0)

{spl_core-7.9.0 → spl_core-7.11.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "spl-core"
-version = "7.9.0"
+version = "7.11.0"
 description = "Software Product Line Support for CMake"
 authors = ["Avengineers <karsten.guenther@kamg.de>"]
 license = "MIT"
@@ -48,6 +48,7 @@ sphinx-book-theme = "^1.1"
 sphinx-design = ">=0.5,<0.7"
 pypeline-semantic-release = ">=0.4.1,<=0.5.0"
 pypeline-runner = ">=1,<=2"
+py7zr = "^1.0.0"
 
 [tool.poetry.group.dev.dependencies]
 pytest = ">=7,<9"

spl_core-7.11.0/src/spl_core/__init__.py

@@ -0,0 +1 @@
+__version__ = "7.11.0"

{spl_core-7.9.0 → spl_core-7.11.0}/src/spl_core/common.cmake

@@ -10,31 +10,81 @@ macro(_spl_get_absolute_path out in)
     endif()
 endmacro()
 
+# SPL_ADD_COMPONENT
+#
+# Arguments:
+#
+# component_path - the path to the component's directory
+# [target_executable] - (optional) name of the target executable. This is the second argument of the macro.
+#
+# Needs to know:
+#
+# component_path - because it must call add_subdirectory to the component's directory
+# target_executable
+#   - required to determine the build directory for the component (one can not call add_subdirectory
+#     for the same component multiple times with the same build directory)
+#   - must be set to the "global" scope because it is required in spl_create_component to append it to the component name.
+#     spl_create_component gets to decide the component name and will make it "global" for this macro to read it back.
+#
 macro(spl_add_component component_path)
-    message(DEBUG "spl_add_component: component_path=${component_path}")
-    _spl_slash_to_underscore(component_name ${component_path})
-    add_subdirectory(${CMAKE_SOURCE_DIR}/${component_path})
+    set(target_executable "${ARGV1}")
+    message(DEBUG "spl_add_component: component_path=${component_path}, target_executable=${target_executable}")
 
-    if(TARGET ${component_name})
+    # Set global variables for spl_create_component
+    unset(GLOBAL__SPL_ADD_COMPONENT__TARGET_EXECUTABLE)
+    if("${target_executable}" STREQUAL "")
+        set(target_executable ${LINK_TARGET_NAME})
+        add_subdirectory(${CMAKE_SOURCE_DIR}/${component_path})
+    else()
+        set(GLOBAL__SPL_ADD_COMPONENT__TARGET_EXECUTABLE "${target_executable}")
+        add_subdirectory(${CMAKE_SOURCE_DIR}/${component_path} "${CMAKE_BINARY_DIR}/${target_executable}/${component_path}")
+    endif()
+    # Add the newly created component to the linked libraries
+    if(TARGET ${GLOBAL__SPL_CREATE_COMPONENT__NEW_COMPONENT_NAME})
         if(BUILD_KIT STREQUAL prod)
-            target_link_libraries(${LINK_TARGET_NAME} ${component_name})
+            target_link_libraries(${target_executable} ${GLOBAL__SPL_CREATE_COMPONENT__NEW_COMPONENT_NAME})
         endif()
     endif()
 endmacro()
 
+# SPL_ADD_NAMED_COMPONENT
+#
+# Arguments:
+#
+# component_name - the name of the component. (!) This macro expects that a CMake variable with this name holds the component path.
+#                  This means that ${${component_name}} is the component path.
+# [target_executable] - (optional) name of the target executable.
+#
+# Needs to know:
+#
+# component_path - because it must call add_subdirectory to the component's directory
+# target_executable
+#   - required to determine the build directory for the component (one can not call add_subdirectory
+#     for the same component multiple times without specifying the build directory)
+#   - must be set to the "global" scope because it is required in spl_create_component to append it to the component name
+#
 macro(spl_add_named_component component_name)
-    message(DEBUG "spl_add_named_component: component_name=${component_name}")
+    set(target_executable "${ARGV1}")
     set(component_path ${${component_name}})
+    if(NOT IS_ABSOLUTE ${component_path})
+        set(component_path ${CMAKE_SOURCE_DIR}/${component_path})
+    endif()
+    message(DEBUG "spl_add_named_component: component_name=${component_name}, component_path=${component_path}, target_executable=${target_executable}")
 
-    if(IS_ABSOLUTE ${component_path})
+    # Set global variables for spl_create_component
+    unset(GLOBAL__SPL_ADD_COMPONENT__TARGET_EXECUTABLE)
+    if("${target_executable}" STREQUAL "")
+        set(target_executable ${LINK_TARGET_NAME})
         add_subdirectory(${component_path})
     else()
-        add_subdirectory(${CMAKE_SOURCE_DIR}/${component_path})
+        set(GLOBAL__SPL_ADD_COMPONENT__TARGET_EXECUTABLE "${target_executable}")
+        add_subdirectory(${component_path} "${CMAKE_BINARY_DIR}/${target_executable}/${component_name}")
     endif()
 
-    if(TARGET ${component_name})
+    # Add the newly created component to the linked libraries
+    if(TARGET ${GLOBAL__SPL_CREATE_COMPONENT__NEW_COMPONENT_NAME})
         if(BUILD_KIT STREQUAL prod)
-            target_link_libraries(${LINK_TARGET_NAME} ${component_name})
+            target_link_libraries(${target_executable} ${GLOBAL__SPL_CREATE_COMPONENT__NEW_COMPONENT_NAME})
         endif()
     endif()
 endmacro()
@@ -121,6 +171,20 @@ macro(_spl_get_google_test)
     enable_testing()
 endmacro(_spl_get_google_test)
 
+# SPL_CREATE_COMPONENT
+#
+# Arguments (they are all optional):
+#
+# NAME        - Use this as component name instead of define it from the component path.
+# LONG_NAME   - A longer name of the component to be used in reports.
+# LIBRARY_TYPE - The type of library to create (e.g., STATIC, SHARED, OBJECT)
+#
+# Needs to know:
+# - target_executable - global variable set by the spl_add_component macros to make sure different component
+#                       names are used for different executables
+#
+# The component name will be made "global" such that the spl_add_compoent macro can add it to the executable
+#
 macro(spl_create_component)
     cmake_parse_arguments(CREATE_COMPONENT "" "NAME;LONG_NAME;LIBRARY_TYPE" "" ${ARGN})
 
@@ -132,11 +196,22 @@ macro(spl_create_component)
     # Determine the unique component name based on the relative path of the component
     file(RELATIVE_PATH component_path ${CMAKE_SOURCE_DIR} ${CMAKE_CURRENT_LIST_DIR})
 
+    unset(GLOBAL__SPL_CREATE_COMPONENT__NEW_COMPONENT_NAME)
     if(NOT CREATE_COMPONENT_NAME)
+        # The component relative path to the project root dictates the component name
         _spl_slash_to_underscore(component_name ${component_path})
     else()
+        # Explicit name provided - use it as-is
         set(component_name ${CREATE_COMPONENT_NAME})
     endif()
+    # If there is a custom target executable, prefix the component name
+    if(GLOBAL__SPL_ADD_COMPONENT__TARGET_EXECUTABLE)
+        set(component_name ${GLOBAL__SPL_ADD_COMPONENT__TARGET_EXECUTABLE}_${component_name})
+    endif()
+    # Make the component name public
+    set(GLOBAL__SPL_CREATE_COMPONENT__NEW_COMPONENT_NAME ${component_name} PARENT_SCOPE)
+
+    message(DEBUG "spl_create_component: component_name=${component_name}")
 
     # Collect all productive sources for later usage (e.g., in an extension)
     list(APPEND PROD_SOURCES ${SOURCES})
@@ -193,8 +268,9 @@ macro(spl_create_component)
 \"reports_output_dir\": \"\"
 }")
     set(_component_is_header_only FALSE)
+
     # If prod and sources or test and test_sources define library. Else make it an interface and set the flag
-    if ((BUILD_KIT STREQUAL prod AND SOURCES) OR
+    if((BUILD_KIT STREQUAL prod AND SOURCES) OR
         (BUILD_KIT STREQUAL test AND TEST_SOURCES))
         add_library(${component_name} ${CREATE_COMPONENT_LIBRARY_TYPE} ${SOURCES})
     else()
@@ -367,6 +443,7 @@ Code Coverage
     # Implicitly add default include directories to provided interfaces
     list(APPEND PROVIDED_INTERFACES ${CMAKE_CURRENT_LIST_DIR}/src)
     list(APPEND PROVIDED_INTERFACES ${CMAKE_CURRENT_BINARY_DIR})
+
     # Get rid of duplicates, in case the default directories where explicitly defined
     list(REMOVE_DUPLICATES PROVIDED_INTERFACES)
 
@@ -382,12 +459,13 @@ Code Coverage
     # Define the target public interfaces to be used instead of the global include directories.
     if(TARGET ${component_name})
         foreach(interfaceDir IN LISTS PROVIDED_INTERFACES)
-            if (_component_is_header_only)
+            if(_component_is_header_only)
                 target_include_directories(${component_name} INTERFACE ${interfaceDir})
             else()
                 target_include_directories(${component_name} PUBLIC ${interfaceDir})
             endif()
         endforeach()
+
         foreach(component IN LISTS REQUIRED_INTERFACES)
             if(_component_is_header_only)
                 target_link_libraries(${component_name} INTERFACE ${component})
@@ -740,7 +818,7 @@ macro(spl_run_conan)
 endmacro(spl_run_conan)
 
 macro(_spl_set_ninja_wrapper_as_cmake_make)
-    set (NINJA_WRAPPER ${CMAKE_CURRENT_BINARY_DIR}/ninja_wrapper.bat)
+    set(NINJA_WRAPPER ${CMAKE_CURRENT_BINARY_DIR}/ninja_wrapper.bat)
     file(WRITE ${NINJA_WRAPPER}
         "@echo off
 @call %~dp0%/activate_run.bat

spl_core-7.11.0/src/spl_core/test_utils/artifacts_archiver.py

@@ -0,0 +1,318 @@
+import json
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import py7zr
+
+
+class ArtifactsArchive:
+    """
+    This class represents a single archive containing artifacts.
+    It collects artifacts to be packed and archived.
+
+    Currently supports 7z and Artifactory.
+    """
+
+    @dataclass
+    class ArchiveArtifact:
+        """
+        Represents a single artifact to be archived.
+        This class holds the archive path (relative to the output directory of the 7z archive)
+        and the absolute path of the artifact.
+        It is used to ensure that artifacts are correctly archived with their intended paths.
+        """
+
+        archive_path: Path
+        absolute_path: Path
+
+    def __init__(self, out_dir: Path, archive_name: str) -> None:
+        self.out_dir: Path = out_dir
+        self.archive_name: str = archive_name
+        self.archive_artifacts: List[ArtifactsArchive.ArchiveArtifact] = []
+
+    def register(self, artifacts: List[Path]) -> None:
+        """
+        Register artifacts for archiving.
+        Args:
+            artifacts: List of paths to artifacts (files or directories) to be archived.
+        """
+        for artifact in artifacts:
+            self._add_artifact(artifact)
+
+    def _add_artifact(self, artifact_path: Path) -> None:
+        """
+        Add an artifact (file or directory) to the archive list.
+        Args:
+            artifact_path: path to the artifact to be archived.
+        """
+        # Convert to absolute path first
+        absolute_path = artifact_path.resolve() if not artifact_path.is_absolute() else artifact_path
+
+        # Calculate the relative path from out_dir for the archive
+        if absolute_path.is_relative_to(self.out_dir.absolute()):
+            archive_path = absolute_path.relative_to(self.out_dir.absolute())
+        else:
+            # If not relative to out_dir, just use the name
+            archive_path = Path(absolute_path.name)
+
+        self.archive_artifacts.append(
+            self.ArchiveArtifact(
+                archive_path=archive_path,
+                absolute_path=absolute_path,
+            )
+        )
+
+    def create_archive(self) -> Path:
+        """
+        Create a 7z file containing the collected artifacts.
+        Returns:
+            Path: The path to the created 7z file.
+        Raises:
+            Exception: If there is an error creating the 7z file.
+        """
+        # Construct the full archive path
+        archive_path = self.out_dir / self.archive_name
+
+        # Create output directory if it doesn't exist
+        archive_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Delete the file if it already exists
+        if archive_path.exists():
+            archive_path.unlink()
+
+        if not self.archive_artifacts:
+            print("Warning: No artifacts registered for archiving")
+            # Create empty 7z file
+            with py7zr.SevenZipFile(archive_path, "w") as archive:
+                pass
+            return archive_path
+
+        try:
+            with py7zr.SevenZipFile(archive_path, "w") as archive:
+                for artifact in self.archive_artifacts:
+                    if not artifact.absolute_path.exists():
+                        print(f"Warning: Artifact {artifact.absolute_path} does not exist, skipping")
+                        continue
+
+                    try:
+                        if artifact.absolute_path.is_file():
+                            archive.write(artifact.absolute_path, arcname=str(artifact.archive_path))
+                        elif artifact.absolute_path.is_dir():
+                            # py7zr can handle directories directly
+                            archive.writeall(artifact.absolute_path, arcname=str(artifact.archive_path))
+                    except Exception as file_error:
+                        print(f"Warning: Failed to add {artifact.absolute_path} to archive: {file_error}")
+                        continue
+
+            print(f"7z file created at: {archive_path}")
+            return archive_path
+        except Exception as e:
+            print(f"Error creating artifacts 7z file: {e}")
+            raise e
+
+
+class ArtifactsArchiver:
+    """
+    This class manages multiple ArtifactsArchive instances.
+    It provides a unified interface for registering artifacts to different archives.
+    """
+
+    def __init__(self) -> None:
+        self.archives: Dict[str, ArtifactsArchive] = {}
+        self._target_repos: Dict[str, str] = {}
+
+    def add_archive(self, out_dir: Path, archive_filename: str, target_repo: Optional[str] = None, archive_name: str = "default") -> ArtifactsArchive:
+        """
+        Add a new archive to the archiver.
+
+        Args:
+            out_dir: Output directory for the archive
+            archive_filename: Filename for the archive
+            target_repo: Target repository path for Artifactory upload (optional)
+            archive_name: Name identifier for the archive (defaults to "default")
+
+        Returns:
+            The created ArtifactsArchive instance
+        """
+        archive = ArtifactsArchive(out_dir, archive_filename)
+        self.archives[archive_name] = archive
+        # Store the target repo information for this archive only if provided
+        if target_repo is not None:
+            self._target_repos[archive_name] = target_repo
+        return archive
+
+    def register(self, artifacts: List[Path], archive_name: str = "default") -> None:
+        """
+        Register artifacts for archiving to a specific archive.
+
+        Args:
+            artifacts: List of paths to artifacts (files or directories) to be archived.
+            archive_name: Name of the archive to register artifacts to (defaults to "default")
+
+        Raises:
+            KeyError: If the specified archive_name doesn't exist
+        """
+        if archive_name not in self.archives:
+            raise KeyError(f"Archive '{archive_name}' not found. Available archives: {list(self.archives.keys())}")
+
+        self.archives[archive_name].register(artifacts)
+
+    def get_archive(self, archive_name: str) -> ArtifactsArchive:
+        """
+        Get a specific archive by name.
+
+        Args:
+            archive_name: Name of the archive to retrieve
+
+        Returns:
+            The ArtifactsArchive instance
+
+        Raises:
+            KeyError: If the specified archive_name doesn't exist
+        """
+        if archive_name not in self.archives:
+            raise KeyError(f"Archive '{archive_name}' not found. Available archives: {list(self.archives.keys())}")
+
+        return self.archives[archive_name]
+
+    def create_all_archives(self) -> Dict[str, Path]:
+        """
+        Create all registered archives.
+
+        Returns:
+            Dictionary mapping archive names to their created file paths
+        """
+        created_archives = {}
+        for archive_name, archive in self.archives.items():
+            created_archives[archive_name] = archive.create_archive()
+        return created_archives
+
+    def create_rt_upload_json(self, out_dir: Path) -> Path:
+        """
+        Create a single rt-upload.json file containing all archives.
+
+        This function replicates the logic from the Jenkinsfile for determining the RT_TARGET
+        and creating the upload specification file. It uses Jenkins environment variables
+        when available, otherwise falls back to default values.
+
+        Args:
+            output_dir: Directory where the rt-upload.json file will be created
+
+        Returns:
+            Path to the created rt-upload.json file
+        """
+        # Set local defaults first
+        change_id = None
+        branch_name = "local_branch"
+        build_number = "local_build"
+
+        # Adapt values when Jenkins environment is detected
+        # TODO: check if an existing library can be used for CI context detection
+        if os.environ.get("JENKINS_URL"):
+            change_id = os.environ.get("CHANGE_ID")
+            jenkins_branch_name = os.environ.get("BRANCH_NAME")
+            jenkins_build_number = os.environ.get("BUILD_NUMBER")
+            tag_name = os.environ.get("TAG_NAME")
+
+            if change_id:
+                # Pull request case
+                branch_name = f"PR-{change_id}"
+            elif tag_name:
+                # Tag build case
+                branch_name = tag_name
+            elif jenkins_branch_name:
+                # Regular branch case
+                branch_name = jenkins_branch_name
+
+            if jenkins_build_number:
+                build_number = jenkins_build_number
+
+        # Create the files array for Artifactory upload format
+        files_array = []
+
+        for archive_name, archive in self.archives.items():
+            if archive_name in self._target_repos:
+                target_repo = self._target_repos[archive_name]
+
+                # Construct the RT target path
+                rt_target = f"{target_repo}/{branch_name}/{build_number}/"
+
+                # Add this archive to the files array
+                files_array.append(
+                    {
+                        "pattern": archive.archive_name,
+                        "target": rt_target,
+                        "recursive": "false",
+                        "flat": "false",
+                        "regexp": "false",
+                    }
+                )
+
+        # Create the single rt-upload.json file
+        json_path = out_dir / "rt-upload.json"
+
+        spec = {"files": files_array}
+
+        with open(json_path, "w") as f:
+            json.dump(spec, f, indent=4)
+
+        return json_path
+
+    def list_archives(self) -> List[str]:
+        """
+        Get a list of all archive names.
+
+        Returns:
+            List of archive names
+        """
+        return list(self.archives.keys())
+
+    def create_archive(self, archive_name: str = "default") -> Path:
+        """
+        Create a specific archive (convenience method for single-archive use case).
+
+        Args:
+            archive_name: Name of the archive to create (defaults to "default")
+
+        Returns:
+            Path to the created archive file
+
+        Raises:
+            KeyError: If the specified archive_name doesn't exist
+        """
+        if archive_name not in self.archives:
+            raise KeyError(f"Archive '{archive_name}' not found. Available archives: {list(self.archives.keys())}")
+
+        return self.archives[archive_name].create_archive()
+
+
+# Example usage:
+#
+# ## Simple single-archive use case with target repo:
+# archiver = ArtifactsArchiver()
+# archiver.add_archive(Path("./build/output"), "results.7z", "my-repo/results")  # uses "default" name
+# archiver.register([Path("./build/test_report.xml"), Path("./build/coverage.html")])  # registers to "default"
+# archive_path = archiver.create_archive()  # creates the "default" archive
+# upload_json = archiver.create_rt_upload_json(Path("./build/output"))
+#
+# ## Simple single-archive use case without target repo (archive only):
+# archiver = ArtifactsArchiver()
+# archiver.add_archive(Path("./build/output"), "results.7z")  # no target repo, uses "default" name
+# archiver.register([Path("./build/test_report.xml"), Path("./build/coverage.html")])
+# archive_path = archiver.create_archive()  # creates the "default" archive
+# # upload_json = archiver.create_rt_upload_json(Path("./build/output"))  # would create empty JSON
+#
+# ## Multi-archive use case:
+# archiver = ArtifactsArchiver()
+# archiver.add_archive(Path("./build/output"), "test_results.7z", "my-repo/test-results", "test_results")
+# archiver.add_archive(Path("./build/output"), "coverage.7z", "my-repo/coverage", "coverage_reports")
+# archiver.add_archive(Path("./build/output"), "docs.7z", None, "documentation")  # no target repo for docs
+#
+# archiver.register([Path("./build/test_report.xml")], "test_results")
+# archiver.register([Path("./build/coverage.html")], "coverage_reports")
+# archiver.register([Path("./build/docs/")], "documentation")
+#
+# created_files = archiver.create_all_archives()
+# upload_json = archiver.create_rt_upload_json(Path("./build/output"))  # only includes archives with target repos

spl_core-7.9.0/src/spl_core/__init__.py

@@ -1 +0,0 @@
-__version__ = "7.9.0"