robotcode-analyze 1.0.2__tar.gz → 1.1.0__tar.gz

{robotcode_analyze-1.0.2 → robotcode_analyze-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotcode-analyze
-Version: 1.0.2
+Version: 1.1.0
 Summary: RobotCode analyze plugin for Robot Framework
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode
@@ -25,9 +25,9 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.8
-Requires-Dist: robotcode-plugin==1.0.2
-Requires-Dist: robotcode-robot==1.0.2
-Requires-Dist: robotcode==1.0.2
+Requires-Dist: robotcode-plugin==1.1.0
+Requires-Dist: robotcode-robot==1.1.0
+Requires-Dist: robotcode==1.1.0
 Requires-Dist: robotframework>=4.1.0
 Description-Content-Type: text/markdown
 

{robotcode_analyze-1.0.2 → robotcode_analyze-1.1.0}/pyproject.toml

@@ -27,9 +27,9 @@ classifiers = [
 ]
 dependencies = [
   "robotframework>=4.1.0",
-  "robotcode-plugin==1.0.2",
-  "robotcode-robot==1.0.2",
-  "robotcode==1.0.2",
+  "robotcode-plugin==1.1.0",
+  "robotcode-robot==1.1.0",
+  "robotcode==1.1.0",
 ]
 dynamic = ["version"]
 

robotcode_analyze-1.1.0/src/robotcode/analyze/__version__.py

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

robotcode_analyze-1.1.0/src/robotcode/analyze/cli.py

@@ -0,0 +1,26 @@
+import click
+
+from robotcode.plugin import Application, pass_application
+
+from .__version__ import __version__
+from .code.cli import code
+
+
+@click.group(
+    add_help_option=True,
+    invoke_without_command=False,
+)
+@click.version_option(
+    version=__version__,
+    package_name="robotcode.analyze",
+    prog_name="RobotCode Analyze",
+)
+@pass_application
+def analyze(app: Application) -> None:
+    """\
+    The analyze command provides various subcommands for analyzing Robot Framework code.
+    These subcommands support specialized tasks, such as code analysis, style checking or dependency graphs.
+    """
+
+
+analyze.add_command(code)

{robotcode_analyze-1.0.2/src/robotcode/analyze → robotcode_analyze-1.1.0/src/robotcode/analyze/code}/cli.py

@@ -16,27 +16,9 @@ from robotcode.robot.config.loader import (
 )
 from robotcode.robot.config.utils import get_config_files
 
-from .__version__ import __version__
+from ..__version__ import __version__
+from ..config import AnalyzeConfig, ExitCodeMask, ModifiersConfig
 from .code_analyzer import CodeAnalyzer, DocumentDiagnosticReport, FolderDiagnosticReport
-from .config import AnalyzeConfig, ModifiersConfig
-
-
-@click.group(
-    add_help_option=True,
-    invoke_without_command=False,
-)
-@click.version_option(
-    version=__version__,
-    package_name="robotcode.analyze",
-    prog_name="RobotCode Analyze",
-)
-@pass_application
-def analyze(app: Application) -> None:
-    """\
-    The analyze command provides various subcommands for analyzing Robot Framework code.
-    These subcommands support specialized tasks, such as code analysis, style checking or dependency graphs.
-    """
-
 
 SEVERITY_COLORS = {
     DiagnosticSeverity.ERROR: "red",
@@ -55,7 +37,8 @@ class ReturnCode(Flag):
 
 
 class Statistic:
-    def __init__(self) -> None:
+    def __init__(self, exit_code_mask: ExitCodeMask) -> None:
+        self.exit_code_mask = exit_code_mask
         self._folders: Set[WorkspaceFolder] = set()
         self._files: Set[TextDocument] = set()
         self._diagnostics: List[Union[DocumentDiagnosticReport, FolderDiagnosticReport]] = []
@@ -104,18 +87,34 @@ class Statistic:
 
     def calculate_return_code(self) -> ReturnCode:
         return_code = ReturnCode.SUCCESS
-        if self.errors > 0:
+        if self.errors > 0 and not self.exit_code_mask & ExitCodeMask.ERROR:
             return_code |= ReturnCode.ERRORS
-        if self.warnings > 0:
+        if self.warnings > 0 and not self.exit_code_mask & ExitCodeMask.WARN:
             return_code |= ReturnCode.WARNINGS
-        if self.infos > 0:
+        if self.infos > 0 and not self.exit_code_mask & ExitCodeMask.INFO:
             return_code |= ReturnCode.INFOS
-        if self.hints > 0:
+        if self.hints > 0 and not self.exit_code_mask & ExitCodeMask.HINT:
             return_code |= ReturnCode.HINTS
         return return_code
 
 
-@analyze.command(
+def _parse_exit_code_mask(ctx: click.Context, param: click.Option, value: Tuple[str, ...]) -> ExitCodeMask:
+    try:
+        return ExitCodeMask.parse(value)
+    except KeyError as e:
+        raise click.BadParameter(str(e)) from e
+
+
+def _split_comma(ctx: click.Context, param: click.Option, value: Optional[List[str]]) -> List[str]:
+    if value is None:
+        return []
+    result: List[str] = []
+    for item in value:
+        result.extend([x.strip() for x in item.split(",") if x.strip()])
+    return result
+
+
+@click.command(
     add_help_option=True,
 )
 @click.version_option(
@@ -199,6 +198,24 @@ class Statistic:
     multiple=True,
     help="Specifies the diagnostics codes to treat as hint.",
 )
+@click.option(
+    "--exit-code-mask",
+    "-xm",
+    multiple=True,
+    callback=_parse_exit_code_mask,
+    metavar="[" + "|".join(member.name.lower() for member in ExitCodeMask if member.name is not None) + "|all]",
+    help="Specifies which diagnostic severities should not affect the exit code. "
+    "For example, with 'warn' in the mask, warnings won't cause a non-zero exit code.",
+)
+@click.option(
+    "--extend-exit-code-mask",
+    "-xe",
+    multiple=True,
+    callback=_parse_exit_code_mask,
+    metavar="[" + "|".join(member.name.lower() for member in ExitCodeMask if member.name is not None) + "|all]",
+    help="Extend the exit code mask with the specified values. This appends to the default mask, defined in the config"
+    " file.",
+)
 @click.argument(
     "paths", nargs=-1, type=click.Path(exists=True, dir_okay=True, file_okay=True, readable=True, path_type=Path)
 )
@@ -214,6 +231,8 @@ def code(
     modifiers_warning: Tuple[str, ...],
     modifiers_information: Tuple[str, ...],
     modifiers_hint: Tuple[str, ...],
+    exit_code_mask: ExitCodeMask,
+    extend_exit_code_mask: ExitCodeMask,
     paths: Tuple[Path],
 ) -> None:
     """\
@@ -309,7 +328,14 @@ def code(
                 analyzer_config.modifiers.hint = []
             analyzer_config.modifiers.hint.extend(modifiers_hint)
 
-        statistics = Statistic()
+        default_mask = (
+            exit_code_mask
+            if exit_code_mask != ExitCodeMask.NONE
+            else ExitCodeMask.parse(analyzer_config.code.exit_code_mask if analyzer_config.code is not None else None)
+        )
+        mask = default_mask | extend_exit_code_mask
+
+        statistics = Statistic(mask)
         for e in CodeAnalyzer(
             app=app,
             analysis_config=analyzer_config.to_workspace_analysis_config(),

{robotcode_analyze-1.0.2/src/robotcode/analyze → robotcode_analyze-1.1.0/src/robotcode/analyze/code}/code_analyzer.py

@@ -83,7 +83,7 @@ class CodeAnalyzer(DiagnosticsContext):
     ) -> Iterable[Union[DocumentDiagnosticReport, FolderDiagnosticReport]]:
         for folder in self.workspace.workspace_folders:
             self.app.verbose(f"Initialize folder {folder.uri.to_path()}")
-            initialize_result = self.diagnostics.initialize_folder(folder)
+            initialize_result = self.diagnostics.analyze_folder(folder)
             if initialize_result is not None:
                 diagnostics: List[Diagnostic] = []
                 for item in initialize_result:

{robotcode_analyze-1.0.2/src/robotcode/analyze → robotcode_analyze-1.1.0/src/robotcode/analyze/code}/diagnostics_context.py

@@ -14,13 +14,13 @@ class DiagnosticHandlers:
     @event
     def document_analyzers(sender, document: TextDocument) -> Optional[List[Diagnostic]]: ...
     @event
-    def folder_initializers(sender, folder: WorkspaceFolder) -> Optional[List[Diagnostic]]: ...
+    def folder_analyzers(sender, folder: WorkspaceFolder) -> Optional[List[Diagnostic]]: ...
 
     @event
     def collectors(sender, document: TextDocument) -> Optional[List[Diagnostic]]: ...
 
-    def initialize_folder(self, folder: WorkspaceFolder) -> List[Union[List[Diagnostic], BaseException, None]]:
-        return self.folder_initializers(
+    def analyze_folder(self, folder: WorkspaceFolder) -> List[Union[List[Diagnostic], BaseException, None]]:
+        return self.folder_analyzers(
             self,
             folder,
             return_exceptions=True,

{robotcode_analyze-1.0.2/src/robotcode/analyze → robotcode_analyze-1.1.0/src/robotcode/analyze/code}/language_provider.py

@@ -2,7 +2,7 @@ from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import Callable, Iterable, List, Optional
 
-from robotcode.analyze.diagnostics_context import DiagnosticsContext
+from robotcode.analyze.code.diagnostics_context import DiagnosticsContext
 from robotcode.core.language import LanguageDefinition
 from robotcode.core.workspace import WorkspaceFolder
 

{robotcode_analyze-1.0.2/src/robotcode/analyze → robotcode_analyze-1.1.0/src/robotcode/analyze/code}/robot_framework_language_provider.py

@@ -5,7 +5,7 @@ from typing import Any, Iterable, List, Optional
 
 from robot.utils import FileReader
 
-from robotcode.analyze.diagnostics_context import DiagnosticsContext
+from robotcode.analyze.code.diagnostics_context import DiagnosticsContext
 from robotcode.core.filewatcher import FileWatcherManagerDummy
 from robotcode.core.ignore_spec import DEFAULT_SPEC_RULES, GIT_IGNORE_FILE, ROBOT_IGNORE_FILE, IgnoreSpec, iter_files
 from robotcode.core.language import LanguageDefinition, language_id
@@ -47,20 +47,25 @@ class RobotFrameworkLanguageProvider(LanguageProvider):
         )
 
         self.diagnostics_context.workspace.documents.on_read_document_text.add(self.on_read_document_text)
-        self.diagnostics_context.diagnostics.folder_initializers.add(self.analyze_folder)
+        self.diagnostics_context.diagnostics.folder_analyzers.add(self.analyze_folder)
         self.diagnostics_context.diagnostics.document_analyzers.add(self.analyze_document)
 
     def _update_python_path(self) -> None:
-        if self.diagnostics_context.workspace.root_uri is not None:
-            for p in self.diagnostics_context.profile.python_path or []:
-                pa = Path(str(p))
-                if not pa.is_absolute():
-                    pa = Path(self.diagnostics_context.workspace.root_uri.to_path(), pa)
-
-                absolute_path = str(pa.absolute())
-                for f in glob.glob(absolute_path):
-                    if Path(f).is_dir() and f not in sys.path:
-                        sys.path.insert(0, f)
+        root_path = (
+            self.diagnostics_context.workspace.root_uri.to_path()
+            if self.diagnostics_context.workspace.root_uri is not None
+            else None
+        )
+
+        for p in self.diagnostics_context.profile.python_path or []:
+            pa = Path(str(p))
+            if root_path is not None and not pa.is_absolute():
+                pa = Path(root_path, pa)
+
+            absolute_path = str(pa.absolute())
+            for f in glob.glob(absolute_path):
+                if Path(f).is_dir() and f not in sys.path:
+                    sys.path.insert(0, f)
 
     @language_id("robotframework")
     def on_read_document_text(self, sender: Any, uri: Uri) -> str:

{robotcode_analyze-1.0.2 → robotcode_analyze-1.1.0}/src/robotcode/analyze/config.py

@@ -1,6 +1,7 @@
 # ruff: noqa: RUF009
 from dataclasses import dataclass
-from typing import List, Optional
+from enum import IntFlag
+from typing import Iterable, List, Literal, Optional, Union
 
 from robotcode.robot.config.model import BaseOptions, field
 from robotcode.robot.diagnostics.workspace_config import (
@@ -197,10 +198,74 @@ class CacheConfig(BaseOptions):
     )
 
 
+class ExitCodeMask(IntFlag):
+    NONE = 0
+    ERROR = 1
+    WARN = 2
+    WARNING = WARN
+    INFO = 4
+    INFORMATION = INFO
+    HINT = 8
+    ALL = ERROR | WARN | INFO | HINT
+
+    @staticmethod
+    def parse(value: Union[Iterable[str], str, None]) -> "ExitCodeMask":
+        if value is None:
+            return ExitCodeMask.NONE
+
+        flags = ExitCodeMask(0)
+        for entry in value:
+            for part_orig in entry.split(","):
+                part = part_orig.strip().upper()
+                if part:
+                    try:
+                        flags |= ExitCodeMask[part]
+                    except KeyError as e:
+                        raise KeyError(f"Invalid exit code mask value: {part_orig}") from e
+        return flags
+
+
+ExitCodeMaskLiteral = Literal["error", "warn", "warning", "info", "information", "hint", "all"]
+ExitCodeMaskList = List[ExitCodeMaskLiteral]
+
+
+@dataclass
+class CodeConfig(BaseOptions):
+    """robotcode-analyze code configuration."""
+
+    exit_code_mask: Optional[ExitCodeMaskList] = field(
+        description="""\
+            Specifies the exit code mask for the code analysis.
+            This is useful if you want to ignore certain types of diagnostics in the result code.
+
+            Examples:
+            ```toml
+            [tool.robotcode-analyze.code]
+            exit_code_mask = ["error", "warn"]
+            ```
+            """,
+    )
+    extend_exit_code_mask: Optional[ExitCodeMaskList] = field(description="Extend the exit code mask setting.")
+
+
 @dataclass
 class AnalyzeConfig(BaseOptions):
     """robotcode-analyze configuration."""
 
+    code: Optional[CodeConfig] = field(
+        description="""\
+            Defines the code analysis configuration.
+
+            Examples:
+
+            ```toml
+            [tool.robotcode-analyze.code]
+            exit_code_mask = "error|warn"
+            ```
+        """
+    )
+    extend_code: Optional[CodeConfig] = field(description="Extend the code analysis configuration.")
+
     modifiers: Optional[ModifiersConfig] = field(
         description="""\
             Defines the modifiers for the analysis.

robotcode_analyze-1.0.2/src/robotcode/analyze/__version__.py

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