robotcode-analyze 0.96.0__tar.gz → 0.97.0__tar.gz

{robotcode_analyze-0.96.0 → robotcode_analyze-0.97.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: robotcode-analyze
-Version: 0.96.0
+Version: 0.97.0
 Summary: RobotCode analyze plugin for Robot Framework
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode
@@ -10,7 +10,6 @@ Project-URL: Issues, https://github.com/robotcodedev/robotcode/issues
 Project-URL: Source, https://github.com/robotcodedev/robotcode
 Author-email: Daniel Biehl <dbiehl@live.de>
 License: Apache-2.0
-License-File: LICENSE.txt
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Framework :: Robot Framework
 Classifier: Framework :: Robot Framework :: Tool
@@ -25,9 +24,9 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.8
-Requires-Dist: robotcode-plugin==0.96.0
-Requires-Dist: robotcode-robot==0.96.0
-Requires-Dist: robotcode==0.96.0
+Requires-Dist: robotcode-plugin==0.97.0
+Requires-Dist: robotcode-robot==0.97.0
+Requires-Dist: robotcode==0.97.0
 Requires-Dist: robotframework>=4.1.0
 Description-Content-Type: text/markdown
 

{robotcode_analyze-0.96.0 → robotcode_analyze-0.97.0}/pyproject.toml

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

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

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

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

@@ -0,0 +1,244 @@
+from pathlib import Path
+from textwrap import indent
+from typing import List, Optional, Set, Tuple
+
+import click
+
+from robotcode.analyze.config import AnalyzeConfig
+from robotcode.core.lsp.types import Diagnostic, DiagnosticSeverity
+from robotcode.core.text_document import TextDocument
+from robotcode.core.uri import Uri
+from robotcode.core.utils.path import try_get_relative_path
+from robotcode.core.workspace import WorkspaceFolder
+from robotcode.plugin import Application, pass_application
+from robotcode.robot.config.loader import (
+    load_robot_config_from_path,
+)
+from robotcode.robot.config.utils import get_config_files
+
+from .__version__ import __version__
+from .code_analyzer import CodeAnalyzer, DocumentDiagnosticReport, FolderDiagnosticReport
+
+
+@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",
+    DiagnosticSeverity.WARNING: "yellow",
+    DiagnosticSeverity.INFORMATION: "blue",
+    DiagnosticSeverity.HINT: "cyan",
+}
+
+
+class Statistic:
+    def __init__(self) -> None:
+        self.folders: Set[WorkspaceFolder] = set()
+        self.files: Set[TextDocument] = set()
+        self.errors = 0
+        self.warnings = 0
+        self.infos = 0
+        self.hints = 0
+
+    def __str__(self) -> str:
+        return (
+            f"Files: {len(self.files)}, Errors: {self.errors}, Warnings: {self.warnings}, "
+            f"Infos: {self.infos}, Hints: {self.hints}"
+        )
+
+
+@analyze.command(
+    add_help_option=True,
+)
+@click.version_option(
+    version=__version__,
+    package_name="robotcode.analyze",
+    prog_name="RobotCode Analyze",
+)
+@click.option(
+    "-f",
+    "--filter",
+    "filter",
+    metavar="PATTERN",
+    type=str,
+    multiple=True,
+    help="""\
+        Glob pattern to filter files to analyze. Can be specified multiple times.
+        """,
+)
+@click.option(
+    "-v",
+    "--variable",
+    metavar="name:value",
+    type=str,
+    multiple=True,
+    help="Set variables in the test data. see `robot --variable` option.",
+)
+@click.option(
+    "-V",
+    "--variablefile",
+    metavar="PATH",
+    type=str,
+    multiple=True,
+    help="Python or YAML file file to read variables from. see `robot --variablefile` option.",
+)
+@click.option(
+    "-P",
+    "--pythonpath",
+    metavar="PATH",
+    type=str,
+    multiple=True,
+    help="Additional locations where to search test libraries"
+    " and other extensions when they are imported. see `robot --pythonpath` option.",
+)
+@click.argument(
+    "paths", nargs=-1, type=click.Path(exists=True, dir_okay=True, file_okay=True, readable=True, path_type=Path)
+)
+@pass_application
+def code(
+    app: Application,
+    filter: Tuple[str],
+    variable: Tuple[str, ...],
+    variablefile: Tuple[str, ...],
+    pythonpath: Tuple[str, ...],
+    paths: Tuple[Path],
+) -> None:
+    """\
+        Performs static code analysis to detect syntax errors, missing keywords or variables,
+        missing arguments, and more on the given *PATHS*. *PATHS* can be files or directories.
+        If no PATHS are given, the current directory is used.
+    """
+
+    config_files, root_folder, _ = get_config_files(
+        paths,
+        app.config.config_files,
+        root_folder=app.config.root,
+        no_vcs=app.config.no_vcs,
+        verbose_callback=app.verbose,
+    )
+
+    try:
+        robot_config = load_robot_config_from_path(
+            *config_files, extra_tools={"robotcode-analyze": AnalyzeConfig}, verbose_callback=app.verbose
+        )
+
+        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()
+
+        if variable:
+            if robot_profile.variables is None:
+                robot_profile.variables = {}
+            for v in variable:
+                name, value = v.split(":", 1) if ":" in v else (v, "")
+                robot_profile.variables.update({name: value})
+
+        if pythonpath:
+            if robot_profile.python_path is None:
+                robot_profile.python_path = []
+            robot_profile.python_path.extend(pythonpath)
+
+        if variablefile:
+            if robot_profile.variable_files is None:
+                robot_profile.variable_files = []
+            for vf in variablefile:
+                robot_profile.variable_files.append(vf)
+
+        statistics = Statistic()
+        for e in CodeAnalyzer(
+            app=app,
+            analysis_config=analyzer_config.to_workspace_analysis_config(),
+            robot_profile=robot_profile,
+            root_folder=root_folder,
+        ).run(paths=paths, filter=filter):
+            if isinstance(e, FolderDiagnosticReport):
+                statistics.folders.add(e.folder)
+
+                if e.items:
+                    _print_diagnostics(app, root_folder, statistics, e.items, e.folder.uri.to_path())
+
+            elif isinstance(e, DocumentDiagnosticReport):
+                statistics.files.add(e.document)
+
+                doc_path = (
+                    e.document.uri.to_path().relative_to(root_folder) if root_folder else e.document.uri.to_path()
+                )
+                if e.items:
+                    _print_diagnostics(app, root_folder, statistics, e.items, doc_path)
+
+        statistics_str = str(statistics)
+        if statistics.errors > 0:
+            statistics_str = click.style(statistics_str, fg="red")
+
+        app.echo(statistics_str)
+
+        app.exit(statistics.errors)
+
+    except (TypeError, ValueError) as e:
+        raise click.ClickException(str(e)) from e
+
+
+def _print_diagnostics(
+    app: Application,
+    root_folder: Optional[Path],
+    statistics: Statistic,
+    diagnostics: List[Diagnostic],
+    folder_path: Optional[Path],
+    print_range: bool = True,
+) -> None:
+    for item in diagnostics:
+        severity = item.severity if item.severity is not None else DiagnosticSeverity.ERROR
+
+        if severity == DiagnosticSeverity.ERROR:
+            statistics.errors += 1
+        elif severity == DiagnosticSeverity.WARNING:
+            statistics.warnings += 1
+        elif severity == DiagnosticSeverity.INFORMATION:
+            statistics.infos += 1
+        elif severity == DiagnosticSeverity.HINT:
+            statistics.hints += 1
+
+        app.echo(
+            (
+                (
+                    f"{folder_path}:"
+                    + (f"{item.range.start.line + 1}:{item.range.start.character + 1}: " if print_range else " ")
+                )
+                if folder_path and folder_path != root_folder
+                else " "
+            )
+            + click.style(f"[{severity.name[0]}] {item.code}", fg=SEVERITY_COLORS[severity])
+            + f": {indent(item.message, prefix='  ').strip()}",
+        )
+
+        if item.related_information:
+            for related in item.related_information or []:
+                related_path = try_get_relative_path(Uri(related.location.uri).to_path(), root_folder)
+
+                app.echo(
+                    f"    {related_path}:"
+                    + (
+                        f"{related.location.range.start.line + 1}:{related.location.range.start.character + 1}: "
+                        if print_range
+                        else " "
+                    )
+                    + f"{indent(related.message, prefix='      ').strip()}",
+                )

{robotcode_analyze-0.96.0 → robotcode_analyze-0.97.0}/src/robotcode/analyze/code_analyzer.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Iterable, List, Optional
+from typing import Iterable, List, Optional, Union
 
 from robotcode.core.ignore_spec import IgnoreSpec
 from robotcode.core.lsp.types import Diagnostic
@@ -12,7 +12,6 @@ from robotcode.plugin import Application
 from robotcode.robot.config.model import RobotBaseProfile
 from robotcode.robot.diagnostics.workspace_config import WorkspaceAnalysisConfig
 
-from .config import AnalyzeConfig
 from .diagnostics_context import DiagnosticHandlers, DiagnosticsContext
 from .robot_framework_language_provider import RobotFrameworkLanguageProvider
 
@@ -23,16 +22,23 @@ class DocumentDiagnosticReport:
     items: List[Diagnostic]
 
 
+@dataclass
+class FolderDiagnosticReport:
+    folder: WorkspaceFolder
+    items: List[Diagnostic]
+
+
 class CodeAnalyzer(DiagnosticsContext):
     def __init__(
         self,
         app: Application,
-        config: AnalyzeConfig,
+        analysis_config: WorkspaceAnalysisConfig,
         robot_profile: RobotBaseProfile,
         root_folder: Optional[Path],
     ):
         self.app = app
-        self._config = config
+        self._analysis_config = analysis_config or WorkspaceAnalysisConfig()
+
         self._robot_profile = robot_profile
         self._root_folder = root_folder if root_folder is not None else Path.cwd()
 
@@ -53,8 +59,8 @@ class CodeAnalyzer(DiagnosticsContext):
                 handler.verbose_callback = app.verbose
 
     @property
-    def analysis_config(self) -> Optional[WorkspaceAnalysisConfig]:
-        return None
+    def analysis_config(self) -> WorkspaceAnalysisConfig:
+        return self._analysis_config
 
     @property
     def profile(self) -> RobotBaseProfile:
@@ -72,8 +78,23 @@ class CodeAnalyzer(DiagnosticsContext):
     def diagnostics(self) -> DiagnosticHandlers:
         return self._dispatcher
 
-    def run(self, paths: Iterable[Path] = {}, filter: Iterable[str] = {}) -> Iterable[DocumentDiagnosticReport]:
+    def run(
+        self, paths: Iterable[Path] = {}, filter: Iterable[str] = {}
+    ) -> 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)
+            if initialize_result is not None:
+                diagnostics: List[Diagnostic] = []
+                for item in initialize_result:
+                    if item is None:
+                        continue
+                    elif isinstance(item, BaseException):
+                        self.app.error(f"Error analyzing {folder.uri.to_path()}: {item}")
+                    else:
+                        diagnostics.extend(item)
+                if diagnostics:
+                    yield FolderDiagnosticReport(folder, diagnostics)
 
             documents = self.collect_documents(folder, paths=paths, filter=filter)
 
@@ -81,16 +102,16 @@ class CodeAnalyzer(DiagnosticsContext):
             for document in documents:
                 analyze_result = self.diagnostics.analyze_document(document)
                 if analyze_result is not None:
-                    diagnostics: List[Diagnostic] = []
+                    diagnostics = []
                     for item in analyze_result:
                         if item is None:
                             continue
                         elif isinstance(item, BaseException):
-                            self.app.error(f"Error analyzing {document.uri}: {item}")
+                            self.app.error(f"Error analyzing {document.uri.to_path()}: {item}")
                         else:
                             diagnostics.extend(item)
-
-                    yield DocumentDiagnosticReport(document, diagnostics)
+                    if diagnostics:
+                        yield DocumentDiagnosticReport(document, diagnostics)
 
             self.app.verbose(f"Collect Diagnostics for {len(documents)} documents")
             for document in documents:
@@ -101,11 +122,11 @@ class CodeAnalyzer(DiagnosticsContext):
                         if item is None:
                             continue
                         elif isinstance(item, BaseException):
-                            self.app.error(f"Error analyzing {document.uri}: {item}")
+                            self.app.error(f"Error analyzing {document.uri.to_path()}: {item}")
                         else:
                             diagnostics.extend(item)
-
-                    yield DocumentDiagnosticReport(document, diagnostics)
+                    if diagnostics:
+                        yield DocumentDiagnosticReport(document, diagnostics)
 
     def collect_documents(
         self, folder: WorkspaceFolder, paths: Iterable[Path] = {}, filter: Iterable[str] = {}

{robotcode_analyze-0.96.0 → robotcode_analyze-0.97.0}/src/robotcode/analyze/config.py

@@ -3,6 +3,12 @@ from dataclasses import dataclass
 from typing import List, Optional
 
 from robotcode.robot.config.model import BaseOptions, field
+from robotcode.robot.diagnostics.workspace_config import (
+    AnalysisDiagnosticModifiersConfig,
+    AnalysisRobotConfig,
+    WorkspaceAnalysisConfig,
+)
+from robotcode.robot.diagnostics.workspace_config import CacheConfig as WorkspaceCacheConfig
 
 
 @dataclass
@@ -246,3 +252,30 @@ class AnalyzeConfig(BaseOptions):
     extend_global_library_search_order: Optional[List[str]] = field(
         description="Extend the global library search order setting."
     )
+
+    def to_workspace_analysis_config(self) -> WorkspaceAnalysisConfig:
+        return WorkspaceAnalysisConfig(
+            exclude_patterns=self.exclude_patterns or [],
+            cache=(
+                WorkspaceCacheConfig(
+                    # TODO savelocation
+                    ignored_libraries=self.cache.ignored_libraries or [],
+                    ignored_variables=self.cache.ignored_variables or [],
+                    ignore_arguments_for_library=self.cache.ignore_arguments_for_library or [],
+                )
+                if self.cache is not None
+                else WorkspaceCacheConfig()
+            ),
+            robot=AnalysisRobotConfig(global_library_search_order=self.global_library_search_order or []),
+            modifiers=(
+                AnalysisDiagnosticModifiersConfig(
+                    ignore=self.modifiers.ignore or [],
+                    error=self.modifiers.error or [],
+                    warning=self.modifiers.warning or [],
+                    information=self.modifiers.information or [],
+                    hint=self.modifiers.hint or [],
+                )
+                if self.modifiers is not None
+                else AnalysisDiagnosticModifiersConfig()
+            ),
+        )

{robotcode_analyze-0.96.0 → robotcode_analyze-0.97.0}/src/robotcode/analyze/diagnostics_context.py

@@ -5,20 +5,29 @@ from robotcode.core.event import event
 from robotcode.core.language import language_id_filter
 from robotcode.core.lsp.types import Diagnostic
 from robotcode.core.text_document import TextDocument
-from robotcode.core.workspace import Workspace
+from robotcode.core.workspace import Workspace, WorkspaceFolder
 from robotcode.robot.config.model import RobotBaseProfile
 from robotcode.robot.diagnostics.workspace_config import WorkspaceAnalysisConfig
 
 
 class DiagnosticHandlers:
     @event
-    def analyzers(sender, document: TextDocument) -> Optional[List[Diagnostic]]: ...
+    def document_analyzers(sender, document: TextDocument) -> Optional[List[Diagnostic]]: ...
+    @event
+    def folder_initializers(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(
+            self,
+            folder,
+            return_exceptions=True,
+        )
+
     def analyze_document(self, document: TextDocument) -> List[Union[List[Diagnostic], BaseException, None]]:
-        return self.analyzers(
+        return self.document_analyzers(
             self,
             document,
             callback_filter=language_id_filter(document),
@@ -37,7 +46,7 @@ class DiagnosticHandlers:
 class DiagnosticsContext(ABC):
     @property
     @abstractmethod
-    def analysis_config(self) -> Optional[WorkspaceAnalysisConfig]: ...
+    def analysis_config(self) -> WorkspaceAnalysisConfig: ...
 
     @property
     @abstractmethod

{robotcode_analyze-0.96.0 → robotcode_analyze-0.97.0}/src/robotcode/analyze/robot_framework_language_provider.py

@@ -1,3 +1,4 @@
+import glob
 import sys
 from pathlib import Path
 from typing import Any, Iterable, List, Optional
@@ -46,7 +47,8 @@ class RobotFrameworkLanguageProvider(LanguageProvider):
         )
 
         self.diagnostics_context.workspace.documents.on_read_document_text.add(self.on_read_document_text)
-        self.diagnostics_context.diagnostics.analyzers.add(self.analyze_document)
+        self.diagnostics_context.diagnostics.folder_initializers.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:
@@ -56,8 +58,9 @@ class RobotFrameworkLanguageProvider(LanguageProvider):
                     pa = Path(self.diagnostics_context.workspace.root_uri.to_path(), pa)
 
                 absolute_path = str(pa.absolute())
-                if absolute_path not in sys.path:
-                    sys.path.insert(0, absolute_path)
+                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:
@@ -70,6 +73,10 @@ class RobotFrameworkLanguageProvider(LanguageProvider):
 
         extensions = self.LANGUAGE_DEFINITION.extensions
 
+        exclude_patterns = [
+            *self.diagnostics_context.analysis_config.exclude_patterns,
+            *(config.exclude_patterns or []),
+        ]
         return filter(
             lambda f: f.suffix.lower() in extensions,
             iter_files(
@@ -77,7 +84,7 @@ class RobotFrameworkLanguageProvider(LanguageProvider):
                 ignore_files=[ROBOT_IGNORE_FILE, GIT_IGNORE_FILE],
                 include_hidden=False,
                 parent_spec=IgnoreSpec.from_list(
-                    [*DEFAULT_SPEC_RULES, *(config.exclude_patterns or [])],
+                    [*DEFAULT_SPEC_RULES, *exclude_patterns],
                     folder.uri.to_path(),
                 ),
                 verbose_callback=self.verbose_callback,
@@ -90,4 +97,9 @@ class RobotFrameworkLanguageProvider(LanguageProvider):
 
         namespace.analyze()
 
-        return namespace.get_diagnostics()
+        return self._document_cache.get_diagnostic_modifier(document).modify_diagnostics(namespace.get_diagnostics())
+
+    def analyze_folder(self, sender: Any, folder: WorkspaceFolder) -> Optional[List[Diagnostic]]:
+        imports_manager = self._document_cache.get_imports_manager_for_workspace_folder(folder)
+
+        return imports_manager.diagnostics

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

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

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

@@ -1,146 +0,0 @@
-from pathlib import Path
-from textwrap import indent
-from typing import Set, Tuple
-
-import click
-
-from robotcode.analyze.config import AnalyzeConfig
-from robotcode.core.lsp.types import DiagnosticSeverity
-from robotcode.core.text_document import TextDocument
-from robotcode.plugin import Application, pass_application
-from robotcode.robot.config.loader import (
-    load_robot_config_from_path,
-)
-from robotcode.robot.config.utils import get_config_files
-
-from .__version__ import __version__
-from .code_analyzer import CodeAnalyzer
-
-
-@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",
-    DiagnosticSeverity.WARNING: "yellow",
-    DiagnosticSeverity.INFORMATION: "blue",
-    DiagnosticSeverity.HINT: "cyan",
-}
-
-
-class Statistic:
-    def __init__(self) -> None:
-        self.files: Set[TextDocument] = set()
-        self.errors = 0
-        self.warnings = 0
-        self.infos = 0
-        self.hints = 0
-
-    def __str__(self) -> str:
-        return (
-            f"Files: {len(self.files)}, Errors: {self.errors}, Warnings: {self.warnings}, "
-            f"Infos: {self.infos}, Hints: {self.hints}"
-        )
-
-
-@analyze.command(
-    add_help_option=True,
-)
-@click.version_option(
-    version=__version__,
-    package_name="robotcode.analyze",
-    prog_name="RobotCode Analyze",
-)
-@click.option(
-    "-f",
-    "--filter",
-    "filter",
-    type=str,
-    multiple=True,
-    help="""\
-        Glob pattern to filter files to analyze. Can be specified multiple times.
-        """,
-)
-@click.argument(
-    "paths", nargs=-1, type=click.Path(exists=True, dir_okay=True, file_okay=True, readable=True, path_type=Path)
-)
-@pass_application
-def code(app: Application, filter: Tuple[str], paths: Tuple[Path]) -> None:
-    """\
-        Performs static code analysis to detect syntax errors, missing keywords or variables,
-        missing arguments, and more on the given *PATHS*. *PATHS* can be files or directories.
-        If no PATHS are given, the current directory is used.
-    """
-
-    config_files, root_folder, _ = get_config_files(
-        paths,
-        app.config.config_files,
-        root_folder=app.config.root,
-        no_vcs=app.config.no_vcs,
-        verbose_callback=app.verbose,
-    )
-
-    try:
-        robot_config = load_robot_config_from_path(
-            *config_files, extra_tools={"robotcode-analyze": AnalyzeConfig}, verbose_callback=app.verbose
-        )
-
-        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()
-
-        statistics = Statistic()
-        for e in CodeAnalyzer(
-            app=app, config=analyzer_config, robot_profile=robot_profile, root_folder=root_folder
-        ).run(paths=paths, filter=filter):
-            statistics.files.add(e.document)
-
-            doc_path = e.document.uri.to_path().relative_to(root_folder) if root_folder else e.document.uri.to_path()
-            if e.items:
-
-                for item in e.items:
-                    severity = item.severity if item.severity is not None else DiagnosticSeverity.ERROR
-
-                    if severity == DiagnosticSeverity.ERROR:
-                        statistics.errors += 1
-                    elif severity == DiagnosticSeverity.WARNING:
-                        statistics.warnings += 1
-                    elif severity == DiagnosticSeverity.INFORMATION:
-                        statistics.infos += 1
-                    elif severity == DiagnosticSeverity.HINT:
-                        statistics.hints += 1
-
-                    app.echo(
-                        f"{doc_path}:{item.range.start.line + 1}:{item.range.start.character + 1}: "
-                        + click.style(f"[{severity.name[0]}] {item.code}", fg=SEVERITY_COLORS[severity])
-                        + f": {indent(item.message, prefix='  ').strip()}",
-                    )
-
-        statistics_str = str(statistics)
-        if statistics.errors > 0:
-            statistics_str = click.style(statistics_str, fg="red")
-
-        app.echo(statistics_str)
-
-        app.exit(statistics.errors)
-
-    except (TypeError, ValueError) as e:
-        raise click.ClickException(str(e)) from e