SmokeCrossFit 0.0.0__py3-none-any.whl

crossfit/__init__.py

@@ -0,0 +1,17 @@
+from crossfit import refs
+from crossfit.commands.command import Command
+from crossfit.tools import Tool, Jacoco, DotnetCoverage, create_tool
+from crossfit.executors import Executor, LocalExecutor, create_executor
+
+__all__ = [
+    'refs',
+    'Command',
+    'Tool',
+    'Jacoco',
+    'DotnetCoverage',
+    'create_tool',
+    'Executor',
+    'LocalExecutor',
+    'create_executor'
+]
+

crossfit/commands/__init__.py

@@ -0,0 +1,3 @@
+from .command import Command
+
+__all__ = ['Command']

crossfit/commands/command.py

@@ -0,0 +1,86 @@
+import copy
+import glob
+from pathlib import Path
+from typing import Optional, List, Tuple, Self
+from typeguard import typechecked
+
+COMMAND_DELIMITER = " "
+
+
+class Command:
+    next_command: Optional[Self]
+    execution_call: Optional[str]
+    command_to_execute: Optional[str]
+    command_body: List[str]
+    options: List[Tuple[str, Optional[str]]]
+    arguments: List[str]
+    values_delimiter: Optional[str]
+
+    @typechecked()
+    def __init__(self):
+        """
+        Initializes the command structure
+        """
+        self.next_command = None
+        self.execution_call = None
+        self.command_to_execute = None
+        self.command_body = []
+        self.options = []
+        self.arguments = []
+        self.values_delimiter = None
+
+    @property
+    def command(self) -> List[str]:
+        """
+        :returns: The command itself as a list of strings
+        """
+        return list(filter(lambda s: s is not None, [self.execution_call, self.command_to_execute, *self.command_body]))
+
+    @command.setter
+    def command(self, value: List[str]):
+        """
+        Sets the command body from a list of strings
+        :param value: The command body as list of strings
+        """
+        self.options = []
+        self.arguments = []
+        self.command_body = value
+
+    def __str__(self) -> str:
+        """
+        :returns: The command itself as a single string
+        """
+        return COMMAND_DELIMITER.join(self.command)
+
+    def validate(self):
+        """
+        Validates that the command has an execution call set
+        :raises AttributeError: If execution call is not set
+        """
+        if not self.execution_call:
+            raise AttributeError(f"Ensure tool's execution call is set. Valued as: '{self.execution_call}'")
+
+    @staticmethod
+    def validate_path(path: Path):
+        """
+        Validates that the given path exists, supports wildcards
+        :param path: The path to validate
+        :raises FileNotFoundError: If the path does not exist
+        """
+        paths = glob.glob(str(path), recursive=True)
+        if not paths:
+            raise FileNotFoundError(f"Could not recognize given path - '{path}' - does not exist")
+
+    def __copy__(self) -> Self:
+        """
+        :returns: A shallow copy of the command
+        """
+        command_copy = Command()
+        command_copy.next_command = copy.copy(self.next_command)
+        command_copy.execution_call = self.execution_call
+        command_copy.command_to_execute = self.command_to_execute
+        command_copy.command_body = self.command_body
+        command_copy.options = self.options
+        command_copy.arguments = self.arguments
+        command_copy.values_delimiter = self.values_delimiter
+        return command_copy

crossfit/commands/command_builder.py

@@ -0,0 +1,176 @@
+import copy
+import glob
+import os.path
+from pathlib import Path
+from typing import List, Optional, Self, Tuple
+from typeguard import typechecked
+from crossfit.commands.command import Command
+
+
+class CommandBuilder:
+    """Builder class for constructing Command objects with a fluent interface."""
+    _command: Command
+
+    def __init__(self):
+        """
+        Initializes a new CommandBuilder instance with an empty Command.
+        """
+        self._command: Command = Command()
+
+    @typechecked()
+    def with_next_command(self, command: Command):
+        """
+        Sets the next command to be executed after the current command.
+        :param command: The Command object to be executed next
+        """
+        self._command.next_command = command
+
+    @typechecked()
+    def with_command(self, command: List[str]) -> Self:
+        """
+        Initializes the command from a list of strings.
+        :param command: A list containing at least two strings - execution call and command to execute
+        :returns: Self for method chaining
+        :raises ValueError: If the command list has fewer than two elements
+        """
+        if len(command) < 2:
+            raise ValueError(
+            'Command construct parameter must have at least two str arguments - execution call and any arguments')
+        self._command.execution_call = command[0]
+        self._command.command_to_execute = command[1]
+        self._command.command_body = command[2:]
+        return self
+
+    @typechecked()
+    def set_execution_call(self, execution_call: str, path: Optional[Path] = None) -> Self:
+        """
+        Sets the execution call for the command.
+        :param execution_call: The executable or interpreter to run
+        :param path: Optional path to prepend to the execution call
+        :returns: Self for method chaining
+        """
+        self._command.execution_call = execution_call if path is None else os.path.relpath(path / execution_call)
+        return self
+
+    @typechecked()
+    def set_command_to_execute(self, command_to_execute: str) -> Self:
+        """
+        Sets the main command or script to execute.
+        :param command_to_execute: The command or script name to execute
+        :returns: Self for method chaining
+        """
+        self._command.command_to_execute = command_to_execute
+        return self
+
+    @typechecked()
+    def set_command_body(self, command_body: List[str]) -> Self:
+        """
+        Sets the command body containing arguments and options.
+        :param command_body: A list of strings representing the command body
+        :returns: Self for method chaining
+        """
+        self._command.command_body = command_body
+        return self
+
+    @typechecked()
+    def set_values_delimiter(self, delimiter: Optional[str], update_current_values: bool = False) -> Self:
+        """
+        Sets the delimiter used between options and their values.
+        :param delimiter: The delimiter string (e.g., '=' or ':'), or None for space separation
+        :param update_current_values: If True, updates all existing options with the new delimiter
+        :returns: Self for method chaining
+        """
+        if self._command.values_delimiter != delimiter:
+            self._command.values_delimiter = delimiter
+            if update_current_values:
+                self.__update_all_options()
+        return self
+
+    @typechecked()
+    def add_option(self, option: str, value: Optional[str] = None, delimiter: Optional[str] = None) -> Self:
+        """
+        Adds a single option to the command.
+        :param option: The option flag or name (e.g., '--verbose' or '-v')
+        :param value: Optional value for the option
+        :param delimiter: Optional delimiter to use for this specific option
+        :returns: Self for method chaining
+        """
+        self.__add_option(option, value, delimiter)
+        return self
+
+    @typechecked()
+    def add_options(self, *args: Tuple[str, Optional[str]]) -> Self:
+        """
+        Adds multiple options to the command.
+        :param args: Variable number of tuples, each containing (option, value) pairs
+        :returns: Self for method chaining
+        """
+        for option in args:
+            self.__add_option(option[0], option[1])
+        return self
+
+    @typechecked()
+    def add_arguments(self, *args) -> Self:
+        """
+        Adds positional arguments to the command.
+        :param args: Variable number of arguments to add
+        :returns: Self for method chaining
+        """
+        self._command.command_body = self._command.command_body[len(self._command.arguments):]
+        self._command.arguments.extend(list(args).copy())
+        self._command.command_body = self._command.arguments + self._command.command_body
+        return self
+
+    @typechecked()
+    def add_path_arguments(self, *paths: Path) -> Self:
+        """
+        Adds path arguments to the command, resolving glob patterns.
+        :param paths: Variable number of Path objects, which may contain glob patterns
+        :returns: Self for method chaining
+        :raises FileNotFoundError: If a path does not exist and is not a valid glob pattern
+        """
+        [self._command.validate_path(path) for path in paths]
+        resolved_glob_paths = []
+        for path in paths:
+            resolved_glob_paths.extend(
+                os.path.relpath(resolved_path) for resolved_path in glob.glob(str(path), recursive=True))
+        self.add_arguments(*[os.path.relpath(path) for path in resolved_glob_paths])
+        return self
+
+    def build_command(self) -> Command:
+        """
+        Builds and returns a copy of the configured Command object.
+        :returns: A copy of the Command object with all configured settings
+        """
+        return copy.copy(self._command)
+
+    def __update_all_options(self) -> Self:
+        """
+        Updates all existing options with the current delimiter.
+        :returns: Self for method chaining
+        """
+        self._command.command_body = self._command.command_body[:-sum(len(option) for option in self._command.options)]
+        options = self._command.options.copy()
+        self._command.options = []
+        self.add_options(*options)
+        return self
+
+    def __add_option(self, option: str, value: Optional[str] = None, delimiter: Optional[str] = None) -> Self:
+        """
+        Internal method to add an option to the command body.
+        :param option: The option flag or name
+        :param value: Optional value for the option
+        :param delimiter: Optional delimiter to override the default
+        :returns: Self for method chaining
+        """
+        if delimiter is not None:
+            self._command.values_delimiter = delimiter
+
+        if value is not None:
+            if self._command.values_delimiter is not None:
+                self._command.command_body.append(f"{option}{self._command.values_delimiter}{value}")
+            else:
+                self._command.command_body.extend([option, value])
+        else:
+            self._command.command_body.append(option)
+        self._command.options.append((option, value))

crossfit/executors/__init__.py

@@ -0,0 +1,5 @@
+from .executor import Executor
+from .local_executor import LocalExecutor
+from .executor_factory import create_executor
+
+__all__ = ['Executor', 'LocalExecutor', 'create_executor']

crossfit/executors/executor.py

@@ -0,0 +1,46 @@
+from abc import ABC, abstractmethod
+from logging import Logger
+
+from crossfit.commands.command import Command
+from crossfit.models.command_models import CommandResult
+
+
+class Executor(ABC):
+    """Abstract base class for command executors."""
+
+    def __init__(self, logger: Logger, catch: bool = True):
+        """
+        :param logger: Logger instance for logging execution details (required)
+        :param catch: If True, catches exceptions and returns error in CommandResult.
+                      If False, re-raises exceptions.
+        """
+        self._logger = logger
+        self._catch = catch
+
+    def execute(self, command: Command) -> CommandResult:
+        """
+        Executes the given command and any chained commands via next_command.
+        :param command: The Command object to execute
+        :returns: Aggregated CommandResult from all executed commands
+        """
+        result = self._execute_single(command)
+
+        current = command.next_command
+        while current is not None:
+            if result.code != 0:
+                self._logger.warning(f"Stopping command chain due to failure. Code: {result.code}")
+                break
+            next_result = self._execute_single(current)
+            result = result.add_result(next_result)
+            current = current.next_command
+
+        return result
+
+    @abstractmethod
+    def _execute_single(self, command: Command) -> CommandResult:
+        """
+        Executes a single command without handling chained commands.
+        :param command: The Command object to execute
+        :returns: CommandResult with execution details
+        """
+        raise NotImplementedError

crossfit/executors/executor_factory.py

@@ -0,0 +1,8 @@
+from crossfit.models.executor_models import ExecutorType
+from crossfit.executors.local_executor import LocalExecutor
+
+def create_executor(executor_type: ExecutorType, logger = None, catch: bool = True, **kwargs):
+    if executor_type == ExecutorType.Local:
+        return LocalExecutor(logger, catch, **kwargs)
+    else:
+        raise ValueError(f"Unknown executor type: {executor_type}")

crossfit/executors/local_executor.py

@@ -0,0 +1,95 @@
+import subprocess
+from logging import Logger
+import shlex
+from crossfit.commands.command import Command
+from crossfit.executors.executor import Executor
+from crossfit.models.command_models import CommandResult
+
+
+class LocalExecutor(Executor):
+    """Executor that runs commands locally via subprocess."""
+
+    def __init__(self, logger: Logger, catch: bool = True, **execution_kwargs):
+        """
+        :param logger: Logger instance for logging execution details (required)
+        :param catch: If True, catches exceptions and returns error in CommandResult.
+                      If False, re-raises exceptions.
+        :param execution_kwargs: Additional arguments passed to subprocess.run
+        """
+        super().__init__(logger, catch)
+        self._exec_kwargs = {
+            "capture_output": True,
+            "check": True,
+            "text": True,
+        }
+        self._exec_kwargs.update(execution_kwargs)
+
+    def _execute_single(self, command: Command) -> CommandResult:
+        """
+        Executes a single command without handling chained commands.
+        :param command: The Command object to execute
+        :returns: CommandResult with execution details
+        """
+        command_str = str(command)
+        try:
+            command.validate()
+            res = subprocess.run(shlex.split(command_str), **self._exec_kwargs)
+
+            if res.returncode != 0 or (res.stderr and len(res.stderr)):
+                raise subprocess.CalledProcessError(
+                    res.returncode, command_str, output=res.stdout, stderr=res.stderr
+                )
+
+            self._logger.info(f"Command '{command_str}' finished with exit code {res.returncode}. {res.stdout}")
+            return CommandResult(
+                code=res.returncode,
+                command=command_str,
+                output=res.stdout,
+                error=res.stderr,
+            )
+
+        except subprocess.CalledProcessError as cpe:
+            self._logger.error(
+                f"Execution of command '{command_str}' failed with error: {cpe.stderr}. Return code {cpe.returncode}."
+            )
+            if not self._catch:
+                raise
+            return CommandResult(
+                code=cpe.returncode,
+                command=command_str,
+                output=cpe.stdout or "",
+                error=cpe.stderr or "",
+            )
+
+        except FileNotFoundError as not_found_e:
+            self._logger.error(f"Command '{command_str}' not found. {not_found_e.strerror}")
+            if not self._catch:
+                raise
+            return CommandResult(
+                code=124,
+                command=command_str,
+                output="",
+                error=not_found_e.strerror,
+            )
+
+        except AttributeError as attr_e:
+            self._logger.error(f"Command validation failed: {attr_e}")
+            if not self._catch:
+                raise
+            return CommandResult(
+                code=1,
+                command=command_str,
+                output="",
+                error=str(attr_e),
+            )
+
+        except Exception as e:
+            self._logger.error(f"An error occurred while executing command '{command_str}': {e}")
+            if not self._catch:
+                raise
+            return CommandResult(
+                code=1,
+                command=command_str,
+                output="",
+                error=str(e),
+            )

crossfit/models/__init__.py

@@ -0,0 +1,5 @@
+from .command_models import CommandResult
+from .tool_models import ToolType, ReportFormat
+from .executor_models import ExecutorType
+
+__all__ = ['CommandResult', 'ToolType', 'ReportFormat', 'ExecutorType']

crossfit/models/command_models.py

@@ -0,0 +1,31 @@
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class CommandType(Enum):
+    SaveReport = "report"
+    SnapshotCoverage = "snapshot"
+    MergeCoverage = "merge"
+    ResetCoverage = "reset"
+
+
+class CommandResult(BaseModel):
+    code: int
+    command: str
+    output: Optional[str] = ""
+    target: Optional[str] = ""
+    error: Optional[str] = ""
+
+
+    def __add__(self, other):
+        self.code &= other.code
+        self.command += " && " + other.command
+        self.output = "\n".join(filter(lambda val: val is not None, (self.output, other.output)))
+        self.target = other.target or self.target
+        self.error = "\n".join(filter(lambda val: val is not None, (self.error, other.error)))
+        return self
+
+    def add_result(self, other):
+        return self + other

crossfit/models/executor_models.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class ExecutorType(Enum):
+    Local = "Local"
+    Remote = "Remote"

crossfit/models/tool_models.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+
+class ToolType(Enum):
+    Jacoco = "jacococli.jar"
+    DotnetCoverage = "dotnet-coverage"
+    DotnetReportGenerator = "reportgenerator"
+
+
+class ReportFormat(Enum):
+    Csv = "Csv"
+    Html = "Html"
+    Xml = "Xml"
+    Cobertura = "Cobertura"

crossfit/refs/__init__.py

@@ -0,0 +1,9 @@
+from pathlib import Path
+
+__filepath = Path(__file__)
+bin_dir = (__filepath.parent.parent / r'bin')
+tools_dir = (bin_dir / r'tools')
+executors_dir = (bin_dir / r'executors')
+deps_dir = (bin_dir / r'deps')
+
+__all__ = ['bin_dir', 'tools_dir', 'deps_dir', 'executors_dir']

crossfit/tools/__init__.py

@@ -0,0 +1,7 @@
+from .dotnet_coverage import DotnetCoverage
+from .jacoco import Jacoco
+from .tool import Tool
+from .tool_factory import create_tool
+
+__all__ = ['Tool', 'Jacoco', 'DotnetCoverage', 'create_tool']
+

crossfit/tools/dotnet_coverage.py

@@ -0,0 +1,77 @@
+from pathlib import Path
+from typing import List, Tuple, Optional
+
+from crossfit import Command
+from crossfit.models import ReportFormat, ToolType
+from crossfit.tools.tool import Tool
+
+
+class DotnetCoverage(Tool):
+    _tool_type = ToolType.DotnetCoverage
+
+    def snapshot_coverage(self, session, target_dir, target_file, *extras: Tuple[str, Optional[str]]) -> Command:
+        """
+        Triggers dotnet-coverage agent to save cobertura formatted coverage files to the given path.
+        :param session: Session id of the dotnet-coverage agent collected-coverage to snapshot.
+        :param target_dir: Targeted directory to save the dotnet-coverage collection to.
+        :param target_file: Specified snapshot file name - when not given, uses default with .xml suffix.
+        :param extras: Extra options to pass to the dotnet-coverage CLI's snapshot command.
+        :return: A Command object configured to snapshot coverage data.
+        """
+        target_path = Path(target_dir) / (
+            target_file if target_file is not None else self._get_default_target_filename())
+        if not target_path.suffix:
+            target_path = target_path.with_suffix(".xml")
+        extras += ("--output", str(target_path)),
+        command_builder = self._create_command_builder(
+            "snapshot", None, None, *extras).add_arguments(session)
+
+        return command_builder.build_command()
+
+    def merge_coverage(self, coverage_files, target_dir, target_file, *extras: Tuple[str, Optional[str]]) -> Command:
+        """
+        Merges multiple coverage files into a single unified coverage file.
+        :param coverage_files: File paths to coverage files to merge.
+        :param target_dir: Targeted directory to save the merged coverage file to.
+        :param target_file: Specified merged file name - when not given, uses default with .xml suffix.
+        :param extras: Extra options to pass to the dotnet-coverage CLI's merge command.
+        :return: A Command object configured to merge coverage files.
+        """
+        extras += ("--output", str(Path(target_dir) / (
+            target_file if target_file is not None else Path(self._get_default_target_filename()).with_suffix(
+                ".xml")))),
+        command_builder = self._create_command_builder("merge", None, coverage_files, *extras)
+        if {"--output-format", "-f"}.intersection(command_builder.build_command().command):
+            command_builder = command_builder.add_option("--output-format", ReportFormat.Cobertura.value.lower())
+
+        return command_builder.build_command()
+
+    def save_report(self, coverage_files, target_dir, sourcecode_dir,
+                    report_format: ReportFormat = None, report_formats: List[ReportFormat] = None,
+                    *extras: Tuple[str, Optional[str]]) -> Command:
+        """
+        Creates a dotnet-coverage report from coverage files to the given path.
+        :param coverage_files: File paths (can handle wildcards) to create dotnet-coverage report from.
+        :param target_dir: Targeted directory to save the dotnet-coverage report to.
+        :param sourcecode_dir: Directory containing the covered source code files.
+        :param report_format: Primary format of the dotnet-coverage report.
+        :param report_formats: Additional formats of dotnet-coverage reports to create.
+        :param extras: Extra options to pass to the dotnet CLI's report command.
+        :return: A Command object configured to generate the coverage report.
+        """
+        multiple_values_delimiter = ';'
+        if sourcecode_dir:
+            extras += ("-sourcedirs", str(sourcecode_dir)),
+        extras += ("-targetdir", str(target_dir)),
+        command_builder = (
+            self._create_command_builder("", ToolType.DotnetReportGenerator, None, *extras)
+            .set_values_delimiter(":", True)
+            .add_option("-reports", f"\"{multiple_values_delimiter.join(map(str, coverage_files))}\""))
+        combined_formats = set((report_formats or []) + [report_format])
+        command_builder = command_builder.add_option(
+            "-reporttypes",f"\"{multiple_values_delimiter.join([rf.value for rf in combined_formats if rf])}\"")
+
+        command = command_builder.build_command()
+        command.command = [kw.replace("--", "-") for kw in command.command[2:]]
+
+        return command

crossfit/tools/jacoco.py

@@ -0,0 +1,105 @@
+import os.path
+from pathlib import Path
+from typing import Optional, Tuple
+from crossfit import Command
+from crossfit.commands.command_builder import CommandBuilder
+from crossfit.models.tool_models import ReportFormat, ToolType
+from crossfit.tools.tool import Tool
+
+
+class Jacoco(Tool):
+    """JaCoCo coverage tool implementation for Java projects."""
+    _tool_type = ToolType.Jacoco
+
+    def _create_command_builder(self, command, tool_type = None, path_arguments = None, required_flags = None,
+                                *extras: Tuple[str, Optional[str]]) -> CommandBuilder:
+        """
+        Creates a CommandBuilder for JaCoCo CLI commands.
+        :param command: The JaCoCo command to execute (e.g., 'report', 'dump', 'merge').
+        :param tool_type: The tool type used to build the command on (defaults to self._tool_type).
+        :param path_arguments: Path arguments to add to the command (e.g., coverage files).
+        :param required_flags: List of required flag options that must be present in extras.
+        :param extras: Extra options to pass to the JaCoCo CLI as tuples of (option, value).
+        :return: A CommandBuilder configured for the JaCoCo command.
+        :raises ValueError: If required flags are missing and catch is False.
+        """
+        tool_type = tool_type or self._tool_type
+        command_builder = (super()._create_command_builder(command, tool_type, path_arguments, *extras)
+                           .set_execution_call(f"java -jar {os.path.relpath(Path(self._path) / str(tool_type.value))}"))
+
+        required_flags = required_flags or []
+        for required_flag in required_flags:
+            if required_flag not in [extra[0] for extra in list(extras)]:
+                msg = (f"Encountered error while building {tool_type.name} command. "
+                       f"JaCoCo flag option {required_flag} is required for command '{command}'.")
+                self._logger.error(msg)
+                if not self._catch:
+                    raise ValueError(msg)
+                command_builder.set_command_body(["--help"])
+
+        return command_builder
+
+    def save_report(self, coverage_files, target_dir, report_format, report_formats, sourcecode_dir, build_dir, *extras)\
+            -> Command:
+        """
+        Creates a JaCoCo coverage report from coverage files to the given path.
+        :param coverage_files: File paths to JaCoCo .exec coverage files to create the report from.
+        :param target_dir: Targeted directory to save the JaCoCo report to.
+        :param report_format: Primary format of the JaCoCo report (e.g., HTML, XML, CSV).
+        :param report_formats: Additional formats of JaCoCo reports to create.
+        :param sourcecode_dir: Directory containing the covered source code files.
+        :param build_dir: Directory containing the compiled class files (required for JaCoCo).
+        :param extras: Extra options to pass to the JaCoCo CLI's report command.
+        :return: A Command object configured to generate the coverage report.
+        """
+        if sourcecode_dir:
+            extras += ("--sourcefiles", str(sourcecode_dir)),
+        if build_dir:
+            extras += ("--classfiles", str(build_dir)),
+        command = self._create_command_builder(
+            "report", None, coverage_files, ["--classfiles"], *extras)
+        combined_formats = set((report_formats or []) + [report_format])
+        for rf in combined_formats:
+            if rf == ReportFormat.Html:
+                command = command.add_option(f"--{rf.name.lower()}", str(target_dir))
+            elif rf is not None:
+                command = command.add_option(f"--{rf.name.lower()}",
+                                             str((Path(target_dir) / self._get_default_target_filename())
+                                                 .with_suffix(f".{rf.value.lower()}")))
+        return command.build_command()
+
+    def snapshot_coverage(self, session, target_dir, target_file, *extras) -> Command:
+        """
+        Triggers JaCoCo agent to dump coverage data to the given path.
+        :param session: Session identifier (not used by JaCoCo dump but kept for interface consistency).
+        :param target_dir: Targeted directory to save the JaCoCo coverage dump to.
+        :param target_file: Specified snapshot file name - when not given, uses default with .exec suffix.
+        :param extras: Extra options to pass to the JaCoCo CLI's dump command.
+        :return: A Command object configured to dump coverage data.
+        """
+        target_path = Path(target_dir) / (
+            target_file if target_file is not None else self._get_default_target_filename())
+        if not target_path.suffix:
+            target_path = target_path.with_suffix(".exec")
+        extras += ("--destfile", str(target_path)),
+        command = self._create_command_builder(
+            "dump", None, None, None, *extras)
+        return command.build_command()
+
+    def merge_coverage(self, coverage_files, target_dir, target_file, *extras) -> Command:
+        """
+        Merges multiple JaCoCo coverage files into a single unified coverage file.
+        :param coverage_files: File paths to JaCoCo .exec coverage files to merge.
+        :param target_dir: Targeted directory to save the merged coverage file to.
+        :param target_file: Specified merged file name - when not given, uses default with .exec suffix.
+        :param extras: Extra options to pass to the JaCoCo CLI's merge command.
+        :return: A Command object configured to merge coverage files.
+        """
+        target_path = Path(target_dir) / (
+            target_file if target_file is not None else self._get_default_target_filename())
+        if not target_path.suffix:
+            target_path = target_path.with_suffix(".exec")
+        extras += ("--destfile", str(target_path)),
+        command = self._create_command_builder(
+            "merge", None, coverage_files, None,*extras)
+        return command.build_command()

crossfit/tools/tool.py

@@ -0,0 +1,90 @@
+import tempfile
+import logging
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Collection, Optional, Tuple, List, Union
+from crossfit.commands.command import Command
+from crossfit.commands.command_builder import CommandBuilder
+from crossfit.models.tool_models import ToolType
+
+
+class Tool(ABC):
+    """Abstract base class for coverage tools. Tools build and return Commands."""
+    _tool_type: ToolType
+    _path: Optional[Path]
+    _logger: logging.Logger
+    _catch: bool
+
+    def __init__(self, logger: logging.Logger, path: Optional[Path] = None, catch: bool = True):
+        """
+        :param logger: Logger instance for logging (required).
+        :param path: The path to the tool executable/jar.
+        :param catch: If True, catches exceptions and returns fallback. If False, re-raises.
+        """
+        self._logger: logging.Logger = logger
+        self._path: Optional[Path] = path
+        self._catch: bool = catch
+
+    def _get_default_target_filename(self) -> str:
+        """Returns the default target filename for this tool."""
+        return f"cross-{self._tool_type.name}".lower()
+
+    def _create_command_builder(self, command: str, tool_type: Optional[ToolType] = None,
+                             path_arguments: Optional[Collection[Path]] = None,
+                             *extras: Tuple[str, Optional[str]]) -> CommandBuilder:
+        """
+        Creates a CommandBuilder for the tool's wanted functionality.
+        :param command: The command of the tool to build on.
+        :param tool_type: The tool type used to build the command on (defaults to self._tool_type).
+        :param path_arguments: Path arguments to add to the command.
+        :param extras: Extra options to pass to the CLI's command as tuples of (option, value).
+        :returns: A CommandBuilder configured for this tool command.
+        """
+        tool_type = tool_type or self._tool_type
+        path_arguments = path_arguments or []
+
+        command_builder = CommandBuilder().set_execution_call(str(tool_type.value), self._path)
+        try:
+            return command_builder.set_command_to_execute(command).add_path_arguments(*path_arguments).add_options(
+                *extras)
+        except FileNotFoundError as e:
+            self._logger.error(f"Encountered exception while building {tool_type.name} command. Error - {e}")
+            if not self._catch:
+                raise
+            return command_builder.set_command_body(["--help"])
+
+    @abstractmethod
+    def save_report(self, coverage_files: List[Union[Path, str]], target_dir: Path, report_format, report_formats,
+                    sourcecode_dir: Optional[Path], build_dir: Optional[Path],
+                    *extras: Tuple[str, Optional[str]]) -> Command:
+        """Builds a command to create a coverage report."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def snapshot_coverage(self, session: str, target_dir: Path, target_file: Optional[Path],
+                          *extras: Tuple[str, Optional[str]]) -> Command:
+        """Builds a command to snapshot coverage data."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def merge_coverage(self, coverage_files: List[Union[Path, str]], target_dir: Path, target_file: Optional[Path],
+                       *extras: Tuple[str, Optional[str]]) -> Command:
+        """Builds a command to merge coverage files."""
+        raise NotImplementedError
+
+    def reset_coverage(self, session: str, *extras: Tuple[str, Optional[str]]) -> Command:
+        """
+        Builds a command to reset coverage data.
+        Uses next_command chaining to snapshot with --reset flag and then clean up temp file.
+        :param session: Session id of the coverage agent.
+        :param extras: Extra options to pass to the CLI's command.
+        :returns: A Command with chained cleanup command via next_command.
+        """
+        target_dir = Path(tempfile.gettempdir()) / r"crossfit"
+        extras = extras + (("--reset", None),)
+
+        snapshot_command = self.snapshot_coverage(session, target_dir, None, *extras)
+        cleanup_command = CommandBuilder().with_command(["rm", "-f", str(target_dir)]).build_command()
+        snapshot_command.next_command = cleanup_command
+
+        return snapshot_command

crossfit/tools/tool_factory.py

@@ -0,0 +1,20 @@
+import os
+from logging import Logger
+from pathlib import Path
+from typing import Union
+
+import crossfit.refs
+from crossfit.tools import Jacoco, DotnetCoverage
+from crossfit.models import ToolType
+
+
+def create_tool(tool_type: ToolType, tool_path: str = None, cwd: Union[str, os.PathLike] = None, logger: Logger = None,
+                catch: bool = True, **kwargs):
+    if cwd:
+        kwargs["cwd"] = cwd
+    if tool_type == ToolType.Jacoco:
+        return Jacoco(logger, Path(tool_path) or Path(crossfit.refs.tools_dir), catch)
+    elif tool_type == ToolType.DotnetCoverage:
+        return DotnetCoverage(logger, Path(tool_path) or Path(crossfit.refs.tools_dir), catch)
+    else:
+        raise ValueError(f"Unknown tool type: {tool_type}")

smokecrossfit-0.0.0.dist-info/METADATA

@@ -0,0 +1,197 @@
+Metadata-Version: 2.4
+Name: SmokeCrossFit
+Version: 0.0.0
+Summary: A unified interface for various code coverage tools (JaCoCo, dotnet-coverage)
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# CrossFit Coverage Tools
+
+CrossFit is a Python package designed to provide a unified interface for various code coverage tools. It wraps the functionality of different coverage CLI tools, allowing developers to use a consistent API regardless of which underlying tool they prefer.
+
+## Installation
+
+To install CrossFit, run:
+
+```bash
+pip install crossfit
+```
+
+## Prerequisites
+
+Before using CrossFit, ensure you have the following installed:
+
+1. Python 3.7 or higher
+2. Java Runtime Environment (JRE) - Required for JaCoCo integration
+3. The specific coverage tools you intend to use (e.g., JaCoCo, dotnet-coverage)
+
+## Supported Tools
+
+CrossFit currently supports the following coverage tools:
+
+1. **JaCoCo** - Java-based code coverage tool
+2. **dotnet-coverage** - .NET coverage tool
+3. **dotnet-reportgenerator** - .NET report generation tool
+
+## Usage
+
+CrossFit provides a unified interface for managing code coverage across different tools. Here's how to use it:
+
+### Basic Usage
+
+```python
+from crossfit.tools.jacoco import Jacoco
+
+# Initialize the JaCoCo tool
+jacoco = Jacoco(tool_path="/path/to/jacoco")
+
+# Save coverage report
+result = jacoco.save_report(
+    coverage_files=["coverage.exec"],
+    target_dir="/output/directory",
+    sourcecode_dir="/source/code"
+)
+```
+
+### Key Features
+
+- **Unified Interface**: Consistent API across different coverage tools
+- **Command Building**: Automatic validation of required flags
+- **Coverage Management**: Merge, snapshot, and save coverage data
+- **Error Handling**: Comprehensive logging and error reporting
+- **Multiple Report Formats**: Support for CSV, HTML, XML, and Cobertura formats
+
+### Example Workflow
+
+```python
+from crossfit.tools.jacoco import Jacoco
+from crossfit.models.tool_models import ReportFormat
+
+# Initialize JaCoCo tool
+jacoco = Jacoco(tool_path="/path/to/jacoco")
+
+# Merge coverage files
+merge_result = jacoco.merge_coverage(
+    coverage_files=["coverage1.exec", "coverage2.exec"],
+    target_dir="/output",
+    target_file="merged.exec"
+)
+
+# Generate HTML report
+report_result = jacoco.save_report(
+    coverage_files=["merged.exec"],
+    target_dir="/reports",
+    sourcecode_dir="/src",
+    report_format=ReportFormat.Html
+)
+```
+
+## Package Structure
+
+The package follows a modular structure:
+
+- `crossfit/tools/jacoco.py`: Implementation of JaCoCo tool wrapper
+- `crossfit/tools/dotnet_coverage.py`: Implementation of .NET coverage tool wrapper  
+- `crossfit/tools/tool.py`: Base tool class and abstract methods
+- `crossfit/models/tool_models.py`: Enum definitions for tool types and report formats
+- `crossfit/models/command_models.py`: Command result models and command types
+- `crossfit/commands/command.py`: Command building and execution utilities
+
+## Core Components
+
+### Tool Models (`crossfit/models/tool_models.py`)
+
+Defines the core enumerations used throughout the package:
+
+- **ToolType**: Enum representing supported tools
+  - `Jacoco`
+  - `DotnetCoverage` 
+  - `DotnetReportGenerator`
+
+- **ReportFormat**: Enum representing supported report formats
+  - `Csv`
+  - `Html`
+  - `Xml`
+  - `Cobertura`
+
+### Command Models (`crossfit/models/command_models.py`)
+
+Provides structured representations of command results:
+
+- **CommandType**: Enum defining command types
+  - `SaveReport`
+  - `SnapshotCoverage`
+  - `MergeCoverage`
+  - `ResetCoverage`
+
+- **CommandResult**: Pydantic model for command execution results with fields:
+  - `code`: Exit code from command execution
+  - `command`: The executed command string
+  - `output`: Standard output from command
+  - `target`: Target path/file of operation
+  - `error`: Error output from command
+
+### Command Builder (`crossfit/commands/command.py`)
+
+Provides utilities for building and executing shell commands:
+
+- **Command**: Class for constructing shell commands with:
+  - Execution call (e.g., `java -jar`)
+  - Command keywords (e.g., `dump`, `merge`, `report`)
+  - Options and arguments
+  - Path validation
+  - Delimiter handling for option-value pairs
+
+## Tool Implementations
+
+### JaCoCo Tool (`crossfit/tools/jacoco.py`)
+
+Implements the JaCoCo coverage tool with methods:
+
+- `save_report()`: Generate coverage reports in various formats
+- `snapshot_coverage()`: Take coverage snapshots
+- `merge_coverage()`: Merge multiple coverage files
+- `_get_command()`: Build validated JaCoCo commands with required flag checking
+
+### DotNet Coverage Tool (`crossfit/tools/dotnet_coverage.py`)
+
+Implements the .NET coverage tool with methods:
+
+- `save_report()`: Generate reports from coverage files
+- `merge_coverage()`: Merge coverage data
+- `snapshot_coverage()`: Capture coverage snapshots
+- `reset_coverage()`: Reset coverage data
+
+## Advanced Usage
+
+### Working with Multiple Report Formats
+
+```python
+from crossfit.tools.jacoco import Jacoco
+from crossfit.models.tool_models import ReportFormat
+
+jacoco = Jacoco(tool_path="/path/to/jacoco")
+
+# Generate multiple report formats
+result = jacoco.save_report(
+    coverage_files=["coverage.exec"],
+    target_dir="/reports",
+    sourcecode_dir="/src",
+    report_formats=[ReportFormat.Html, ReportFormat.Xml, ReportFormat.Cobertura]
+)
+```
+
+### Custom Command Arguments
+
+```python
+from crossfit.tools.jacoco import Jacoco
+
+jacoco = Jacoco(tool_path="/path/to/jacoco")
+
+# Pass custom arguments to commands
+result = jacoco.merge_coverage(
+  ["coverage1.exec", "coverage2.exec"],
+  "/output", "merged.exec",
+  *["--format", "xml"]  # Custom arguments
+)
+```

smokecrossfit-0.0.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+crossfit/__init__.py,sha256=Bdtz57-tapFnCYiIa9V5k_edCRkXWKqbp13xODBEv4c,382
+crossfit/bin/tools/jacococli.jar,sha256=gRx_jGs1jF1oqJc8-oZ_aJK-emcbaXpLE8S0R-ba91w,607951
+crossfit/commands/__init__.py,sha256=Hiu6s_GoE0cxhtbgnc8rUXPUxRejnHOQAAfhpSHheLI,51
+crossfit/commands/command.py,sha256=0ujP5wvzfA0P9WJfzJrucgGWBEuiZjbxs9oMtdTD8p0,2752
+crossfit/commands/command_builder.py,sha256=GLfvt0zXDQYEirQd8VGOjAUQvnpeslk2KLQp4KMYCAw,7128
+crossfit/executors/__init__.py,sha256=7lUt1jO6RQwY_6xorlXaDBsOLlBradx9bKxzS-VSms0,179
+crossfit/executors/executor.py,sha256=xPDTuP8wb9OQNC44Hy6yy9w9tDTT3NuH6oS_fXs_gp0,1665
+crossfit/executors/executor_factory.py,sha256=xSsTU3f8AgeMiFCwyGM4ZOm3p9Lp--KQRIqNY5ueaZI,389
+crossfit/executors/local_executor.py,sha256=dNkHoY5bQxRQbniec1ZwGKt56QKbZP_qwXSW3avTfno,3435
+crossfit/models/__init__.py,sha256=awbAmN1HTp01PWgTB4JNwlg1EF_9w9ecSxqOaUVme4E,205
+crossfit/models/command_models.py,sha256=0bK7deXh16SRMPtHXTyYmqScAVoRzyycO3uNRgImBHo,818
+crossfit/models/executor_models.py,sha256=9d4UYXKvzIMwf_COBHxg23bvBxJp21A97gJP9oAkvb0,92
+crossfit/models/tool_models.py,sha256=CM-JKXzM563BGverMP4jQFWcqcplA5RXcNJwhoWjHHg,266
+crossfit/refs/__init__.py,sha256=OEUVIOc-CDNp7KmmcDzKfwkz9LA7SlRtrD3Y5rjQIIU,270
+crossfit/tools/__init__.py,sha256=YtIhLrhdEtDOOH_TMGr9_tgt59vxN-kM97I5ajeN9LY,196
+crossfit/tools/dotnet_coverage.py,sha256=1NBkj6Inb-qf3LITciu1248oboMhQTShFqveu-tkW0U,4359
+crossfit/tools/jacoco.py,sha256=oLw895WvaVk_2mSeI3vAh7vWswg-daMzTEnl26tx1cY,5992
+crossfit/tools/tool.py,sha256=OL3xVMf56UdCnahwX1rz-U7qZcXWFo7ep5B0CCu6RFs,4296
+crossfit/tools/tool_factory.py,sha256=Fstp2NlIOsfYY6UX8vefJ7_ClrojnsbOMA7J63dDl58,741
+smokecrossfit-0.0.0.dist-info/METADATA,sha256=aCChRaK7lsbSmxFrrKw_6pREAgJLZlX7J7Chd8G-sEc,5648
+smokecrossfit-0.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+smokecrossfit-0.0.0.dist-info/top_level.txt,sha256=rDrcypRByvkrDsESoQmYOSkOKMO7eBPRToxHNQflYOI,9
+smokecrossfit-0.0.0.dist-info/RECORD,,

smokecrossfit-0.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

smokecrossfit-0.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+crossfit