robotcode-analyze 0.91.0__tar.gz → 0.92.0__tar.gz

{robotcode_analyze-0.91.0 → robotcode_analyze-0.92.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: robotcode-analyze
-Version: 0.91.0
+Version: 0.92.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==0.91.0
-Requires-Dist: robotcode-robot==0.91.0
-Requires-Dist: robotcode==0.91.0
+Requires-Dist: robotcode-plugin==0.92.0
+Requires-Dist: robotcode-robot==0.92.0
+Requires-Dist: robotcode==0.92.0
 Requires-Dist: robotframework>=4.1.0
 Description-Content-Type: text/markdown
 

{robotcode_analyze-0.91.0 → robotcode_analyze-0.92.0}/pyproject.toml

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

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

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

{robotcode_analyze-0.91.0 → robotcode_analyze-0.92.0}/src/robotcode/analyze/analyzer.py

@@ -2,13 +2,13 @@ from pathlib import Path
 
 from robotcode.robot.config.model import RobotConfig
 
-from .config import AnalyzerConfig
+from .config import AnalyzeConfig
 
 
 class Analyzer:
     def __init__(
         self,
-        config: AnalyzerConfig,
+        config: AnalyzeConfig,
         robot_config: RobotConfig,
         root_folder: Path,
     ):

{robotcode_analyze-0.91.0 → robotcode_analyze-0.92.0}/src/robotcode/analyze/cli.py

@@ -2,10 +2,9 @@ from typing import Tuple, Union
 
 import click
 
-from robotcode.analyze.config import AnalyzerConfig
+from robotcode.analyze.config import AnalyzeConfig
 from robotcode.plugin import Application, pass_application
 from robotcode.robot.config.loader import (
-    load_config_from_path,
     load_robot_config_from_path,
 )
 from robotcode.robot.config.utils import get_config_files
@@ -30,21 +29,20 @@ def analyze(app: Application, paths: Tuple[str]) -> Union[str, int, None]:
     config_files, root_folder, _ = get_config_files(paths, app.config.config_files, verbose_callback=app.verbose)
 
     try:
-        robot_config = (
-            load_robot_config_from_path(*config_files)
-            .combine_profiles(*(app.config.profiles or []), verbose_callback=app.verbose, error_callback=app.error)
-            .evaluated_with_env()
+        robot_config = load_robot_config_from_path(
+            *config_files, extra_tools={"robotcode-analyze": AnalyzeConfig}, verbose_callback=app.verbose
         )
 
-        analyzer_config = load_config_from_path(
-            AnalyzerConfig,
-            *config_files,
-            tool_name="robotcode-analyze",
-            robot_toml_tool_name="robotcode-analyze",
-        ).evaluated()
+        analyzer_config = robot_config.tool.get("robotcode-analyze", None) if robot_config.tool is not None else None
+        if analyzer_config is None:
+            analyzer_config = AnalyzeConfig()
+
+        robot_profile = robot_config.combine_profiles(
+            *(app.config.profiles or []), verbose_callback=app.verbose, error_callback=app.error
+        ).evaluated_with_env()
 
         app.print_data(analyzer_config)
-        app.print_data(robot_config)
+        app.print_data(robot_profile)
 
     except (TypeError, ValueError) as e:
         raise click.ClickException(str(e)) from e

robotcode_analyze-0.92.0/src/robotcode/analyze/config.py

@@ -0,0 +1,248 @@
+# ruff: noqa: RUF009
+from dataclasses import dataclass
+from typing import List, Optional
+
+from robotcode.robot.config.model import BaseOptions, field
+
+
+@dataclass
+class ModifiersConfig(BaseOptions):
+    """Modifiers configuration."""
+
+    ignore: Optional[List[str]] = field(
+        description="""\
+            Specifies the error codes to ignore.
+
+            Examples:
+
+            ```toml
+            [tool.robotcode-analyze.modifiers]
+            ignore = ["VariableNotFound", "multiple-keywords"]
+            ```
+        """
+    )
+    extend_ignore: Optional[List[str]] = field(
+        description="""
+            Extend the error codes to ignore.
+
+            Examples:
+
+            ```toml
+            [tool.robotcode-analyze.modifiers]
+            extend_ignore = ["VariableNotFound", "multiple-keywords"]
+            ```
+        """
+    )
+    error: Optional[List[str]] = field(
+        description="""
+            Specifies the error codes to treat as errors.
+
+            Examples:
+
+            ```toml
+            [tool.robotcode-analyze.modifiers]
+            error = ["VariableNotFound", "multiple-keywords"]
+            ```
+        """
+    )
+    extend_error: Optional[List[str]] = field(
+        description="""
+            Extend the error codes to treat as errors.
+
+            Examples:
+
+            ```toml
+            [tool.robotcode-analyze.modifiers]
+            extend_error = ["VariableNotFound", "multiple-keywords"]
+            ```
+        """
+    )
+    warning: Optional[List[str]] = field(
+        description="""
+            Specifies the error codes to treat as warning.
+
+            Examples:
+
+            ```toml
+            [tool.robotcode-analyze.modifiers]
+            warning = ["VariableNotFound", "multiple-keywords"]
+            ```
+        """
+    )
+    extend_warning: Optional[List[str]] = field(
+        description="""
+            Extend the error codes to treat as warnings.
+
+            Examples:
+
+            ```toml
+            [tool.robotcode-analyze.modifiers]
+            extend_warning = ["VariableNotFound", "multiple-keywords"]
+            ```
+        """
+    )
+    information: Optional[List[str]] = field(
+        description="""
+            Specifies the error codes to treat as information.
+
+            Examples:
+
+            ```toml
+            [tool.robotcode-analyze.modifiers]
+            information = ["VariableNotFound", "multiple-keywords"]
+            ```
+        """
+    )
+    extend_information: Optional[List[str]] = field(
+        description="""
+            Extend the error codes to treat as information.
+
+            Examples:
+
+            ```toml
+            [tool.robotcode-analyze.modifiers]
+            extend_information = ["VariableNotFound", "multiple-keywords"]
+            ```
+        """
+    )
+    hint: Optional[List[str]] = field(
+        description="""
+            Specifies the error codes to treat as hint.
+
+            Examples:
+
+            ```toml
+            [tool.robotcode-analyze.modifiers]
+            hint = ["VariableNotFound", "multiple-keywords"]
+            ```
+        """
+    )
+    extend_hint: Optional[List[str]] = field(
+        description="""
+            Extend the error codes to treat as hint.
+
+            Examples:
+
+            ```toml
+            [tool.robotcode-analyze.modifiers]
+            extend_hint = ["VariableNotFound", "multiple-keywords"]
+            ```
+        """
+    )
+
+
+@dataclass
+class CacheConfig(BaseOptions):
+    """Cache configuration."""
+
+    cache_dir: Optional[str] = field(description="Path to the cache directory.")
+
+    ignored_libraries: Optional[List[str]] = field(
+        description="""\
+            Specifies the library names that should not be cached.
+            This is useful if you have a dynamic or hybrid library that has different keywords depending on
+            the arguments. You can specify a glob pattern that matches the library name or the source file.
+
+            Examples:
+            - `**/mylibfolder/mylib.py`
+            - `MyLib`\n- `mylib.subpackage.subpackage`
+
+            For robot framework internal libraries, you have to specify the full module name like
+            `robot.libraries.Remote`.
+            """,
+    )
+    extend_ignored_libraries: Optional[List[str]] = field(description="Extend the ignored libraries setting.")
+
+    ignored_variables: Optional[List[str]] = field(
+        description="""\
+            Specifies the variable files that should not be cached.
+            This is useful if you have a dynamic or hybrid variable files that has different variables
+            depending on the arguments. You can specify a glob pattern that matches the variable module
+            name or the source file.
+
+            Examples:
+            - `**/variables/myvars.py`
+            - `MyVariables`
+            - `myvars.subpackage.subpackage`
+            """,
+    )
+    extend_ignored_variables: Optional[List[str]] = field(description="Extend the ignored variables setting.")
+
+    ignore_arguments_for_library: Optional[List[str]] = field(
+        description="""\
+            Specifies a list of libraries for which arguments will be ignored during analysis.
+            This is usefull if you have library that gets variables from a python file as arguments that contains
+            complex data like big dictionaries or complex objects that **RobotCode** can't handle.
+            You can specify a glob pattern that matches the library name or the source file.
+
+            Examples:
+            - `**/mylibfolder/mylib.py`
+            - `MyLib`\n- `mylib.subpackage.subpackage`
+
+            If you change this setting, you may need to run the command
+            `RobotCode: Clear Cache and Restart Language Servers`.
+
+            _Ensure your library functions correctly without arguments e.g. by defining default
+            values for all arguments._
+        """
+    )
+    extend_ignore_arguments_for_library: Optional[List[str]] = field(
+        description="Extend the ignore arguments for library settings."
+    )
+
+
+@dataclass
+class AnalyzeConfig(BaseOptions):
+    """robotcode-analyze configuration."""
+
+    modifiers: Optional[ModifiersConfig] = field(
+        description="""\
+            Defines the modifiers for the analysis.
+
+            Examples:
+
+            ```toml
+            [tool.robotcode-analyze.modifiers]
+            ignore = ["VariableNotFound"]
+            hint = ["KeywordNotFound"]
+            information = ["MultipleKeywords"]
+            ```
+        """
+    )
+    extend_modifiers: Optional[ModifiersConfig] = field(
+        description="""\
+            Extends the modifiers for the analysis.
+
+            Examples:
+
+            ```toml
+            [tool.robotcode-analyze.extend_modifiers]
+            ignore = ["VariableNotFound"]
+            extend-hint = ["KeywordNotFound"]
+            extend-information = ["MultipleKeywords"]
+            ```
+        """
+    )
+
+    cache: Optional[CacheConfig] = field(description="Defines the cache configuration.")
+    extend_cache: Optional[CacheConfig] = field(description="Extend the cache configuration.")
+
+    exclude_patterns: Optional[List[str]] = field(
+        description="Specifies glob patterns for excluding files and folders from analysing by the language server.",
+    )
+    extend_exclude_patterns: Optional[List[str]] = field(description="Extend the exclude patterns.")
+
+    global_library_search_order: Optional[List[str]] = field(
+        description="""\
+            Specifies a global [search order](https://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#specifying-explicit-priority-between-libraries-and-resources)
+            for libraries and resources.
+            This is usefull when you have libraries containing keywords with the same name. **RobotCode** is unable to
+            analyze the library search order in a file specified with
+                [`Set Library Search Order`](https://robotframework.org/robotframework/latest/libraries/BuiltIn.html#Set%20Library%20Search%20Order),
+            so you can define a global order here. Just make sure to call the `Set Library Search Order`
+            keyword somewhere in your robot file or internally in your library.
+        """,
+    )
+    extend_global_library_search_order: Optional[List[str]] = field(
+        description="Extend the global library search order setting."
+    )

robotcode_analyze-0.92.0/src/robotcode/analyze/hooks.py

@@ -0,0 +1,19 @@
+from typing import List
+
+import click
+
+from robotcode.plugin import hookimpl
+from robotcode.plugin.specs import ToolConfig
+
+from .cli import analyze
+from .config import AnalyzeConfig
+
+
+@hookimpl
+def register_cli_commands() -> List[click.Command]:
+    return [analyze]
+
+
+@hookimpl
+def register_tool_config_classes() -> List[ToolConfig]:
+    return [ToolConfig("robotcode-analyze", AnalyzeConfig)]

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

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

robotcode_analyze-0.91.0/src/robotcode/analyze/config.py

@@ -1,59 +0,0 @@
-# ruff: noqa: RUF009
-from dataclasses import dataclass
-from enum import Enum
-from typing import List, Optional
-
-from robotcode.robot.config.model import BaseOptions, field
-
-
-class CacheSaveLocation(Enum):
-    WORKSPACE_FOLDER = "workspaceFolder"
-    WORKSPACE_STORAGE = "workspaceStorage"
-
-
-@dataclass
-class AnalyzerConfig(BaseOptions):
-    select: Optional[List[str]] = field(description="Selects which rules are run.")
-    extend_select: Optional[List[str]] = field(description="Extends the rules which are run.")
-    ignore: Optional[List[str]] = field(description="Defines which rules are ignored.")
-    extend_ignore: Optional[List[str]] = field(description="Extends the rules which are ignored.")
-    exclude_patterns: List[str] = field(default_factory=list)
-
-    cache_dir: Optional[str] = field(description="Path to the cache directory.")
-
-    ignored_libraries: List[str] = field(
-        default_factory=list,
-        description="""\
-            Specifies the library names that should not be cached.
-            This is useful if you have a dynamic or hybrid library that has different keywords depending on
-            the arguments. You can specify a glob pattern that matches the library name or the source file.
-
-            Examples:
-            - `**/mylibfolder/mylib.py`
-            - `MyLib`\n- `mylib.subpackage.subpackage`
-
-            For robot framework internal libraries, you have to specify the full module name like
-            `robot.libraries.Remote`.
-            """,
-    )
-    ignored_variables: List[str] = field(
-        default_factory=list,
-        description="""\
-            Specifies the variable files that should not be cached.
-            This is useful if you have a dynamic or hybrid variable files that has different variables
-            depending on the arguments. You can specify a glob pattern that matches the variable module
-            name or the source file.
-
-            Examples:
-            - `**/variables/myvars.py`
-            - `MyVariables`
-            - `myvars.subpackage.subpackage`
-            """,
-    )
-
-    global_library_search_order: List[str] = field(
-        default_factory=list,
-        description="""\
-            TODO
-        """,
-    )

robotcode_analyze-0.91.0/src/robotcode/analyze/hooks.py

@@ -1,18 +0,0 @@
-from typing import Any, List, Tuple, Type
-
-import click
-
-from robotcode.plugin import hookimpl
-
-from .cli import analyze
-from .config import AnalyzerConfig
-
-
-@hookimpl
-def register_cli_commands() -> List[click.Command]:
-    return [analyze]
-
-
-@hookimpl
-def register_config_classes() -> List[Tuple[str, Type[Any]]]:
-    return [("tool.robotcode-analyze", AnalyzerConfig)]