refactor: Do not load and store cache when cache is not enabled (#1607)

* refactor(caching): Do not load and store cache when cache is not enabled

Reduce amount of cache reads if it's not needed. Split run() method into smaller methods. Implemented hash method inside config class.

* test: re-run performance test

Author: bhirsz

src/robocop/cache.py

@@ -368,7 +368,7 @@ def _is_entry_valid(
             True if the cache entry is valid, False otherwise.
 
         """
-        # Check cheapest condition first (string comparison)
+        # Check the cheapest condition first (string comparison)
         if config_hash != entry_config_hash:
             return False
 
@@ -394,7 +394,7 @@ def _get_entry(
         Args:
             cache_dict: Dictionary containing cache entries (linter or formatter).
             path: Absolute path to the file.
-            config_hash: Hash of current configuration.
+            config_hash: Hash of the current configuration.
 
         Returns:
             Cached entry if valid, None otherwise.
@@ -470,6 +470,8 @@ def set_linter_entry(
             diagnostics: List of diagnostics found.
 
         """
+        if not self.enabled:
+            return
         try:
             metadata = FileMetadata.from_path(path)
         except OSError:

src/robocop/config.py

@@ -713,6 +713,7 @@ class Config:
     verbose: bool | None = field(default_factory=bool)
     silent: bool | None = field(default_factory=bool)
     target_version: int | str | None = misc.ROBOT_VERSION.major
+    _hash: int | None = None
     config_source: str = "cli"
 
     def __post_init__(self) -> None:
@@ -863,6 +864,27 @@ def overwrite_from_config(self, overwrite_config: Config | None) -> None:
     def __str__(self):
         return str(self.config_source)
 
+    def hash(self) -> str:
+        """
+        Compute cache key combining linter config hash with language.
+
+        Uses SHA256 for stable hashing across Python processes, unlike the built-in
+        hash() which can vary due to hash randomization (PEP 456).
+
+        Returns:
+            str: The computed cache key as a hexadecimal digest.
+
+        """
+        if self._hash is None:
+            hasher = hashlib.sha256()
+            # Hash the linter config
+            hasher.update(str(hash(self.linter)).encode("utf-8"))
+            # Hash the language configuration (affects parsing)
+            language_str = ":".join(sorted(self.language or []))
+            hasher.update(language_str.encode("utf-8"))
+            self._hash = hasher.hexdigest()
+        return self._hash
+
 
 class GitIgnoreResolver:
     def __init__(self):

src/robocop/linter/runner.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import hashlib
 from typing import TYPE_CHECKING, NoReturn
 
 import typer
@@ -42,25 +41,39 @@ def get_model_for_file_type(self, source: Path, language: list[str] | None) -> F
             return get_resource_with_lang(get_resource_model, source, language)
         return get_resource_with_lang(get_model, source, language)
 
-    @staticmethod
-    def _compute_cache_key(config: Config) -> str:
+    def get_cached_diagnostics(self, config: Config, source: Path) -> list[Diagnostic] | None:
         """
-        Compute cache key combining linter config hash with language.
+        Return cached diagnostics if available.
 
-        Uses SHA256 for stable hashing across Python processes, unlike the built-in
-        hash() which can vary due to hash randomization (PEP 456).
+        Returns:
+            List of cached diagnostics or None if no cache is available.
+
+        """
+        if not config.cache.enabled:
+            return None
+        cached_entry = self.config_manager.cache.get_linter_entry(source, config.hash())
+
+        if cached_entry is not None:
+            restored = restore_diagnostics(cached_entry, source, config.linter.rules)
+            if restored is not None:
+                return restored
+        return None
+
+    def get_model_diagnostics(self, config: Config, source: Path) -> list[Diagnostic] | None:
+        """
+        Run all selected rules on the model and return list of diagnostics.
 
         Returns:
-            str: The computed cache key as a hexadecimal digest.
+            List of diagnostics or None if file cannot be decoded.
 
         """
-        hasher = hashlib.sha256()
-        # Hash the linter config
-        hasher.update(str(hash(config.linter)).encode("utf-8"))
-        # Hash the language configuration (affects parsing)
-        language_str = ":".join(sorted(config.language or []))
-        hasher.update(language_str.encode("utf-8"))
-        return hasher.hexdigest()
+        try:
+            model = self.get_model_for_file_type(source, config.language)
+            return self.run_check(model, source, config)
+        except DataError as error:
+            if not config.silent:
+                print(f"Failed to decode {source} with an error: {error}. Skipping file")
+            return None
 
     def run(self) -> list[Diagnostic]:
         """
@@ -89,36 +102,18 @@ def run(self) -> list[Diagnostic]:
         for source, config in self.config_manager.paths:
             if config.verbose:
                 print(f"Scanning file: {source}")
-
-            # Try to get cached diagnostics
-            config_hash = self._compute_cache_key(config)
-            cached_entry = self.config_manager.cache.get_linter_entry(source, config_hash)
-
-            if cached_entry is not None:
-                # Restore diagnostics from cache
-                restored = restore_diagnostics(cached_entry, source, config.linter.rules)
-                if restored is not None:
-                    self.diagnostics.extend(restored)
-                    files += 1
-                    cached_files += 1
-                    continue
-                # If restoration failed (e.g., rule removed), fall through to reprocess
-
-            try:
-                model = self.get_model_for_file_type(source, config.language)
-            except DataError as error:
-                if not config.silent:
-                    print(f"Failed to decode {source} with an error: {error}. Skipping file")
+            diagnostics = self.get_cached_diagnostics(config, source)
+            if diagnostics is not None:
+                self.diagnostics.extend(diagnostics)
+                files += 1
+                cached_files += 1
+                continue
+            diagnostics = self.get_model_diagnostics(config, source)
+            if diagnostics is None:
                 continue
-
-            files += 1
-            diagnostics = self.run_check(model, source, config)
             self.diagnostics.extend(diagnostics)
-
-            # Cache the results (config_hash already includes language)
-            self.config_manager.cache.set_linter_entry(source, config_hash, diagnostics)
-
-        # Save cache at the end
+            files += 1
+            self.config_manager.cache.set_linter_entry(source, config.hash(), diagnostics)
         self.config_manager.cache.save()
 
         if not files and not self.config_manager.default_config.silent:

tests/performance/reports/robocop_7_1_0.json

@@ -1,19 +1,19 @@
 {
     "linter_report": {
         "with_print_cache": {
-            "avg_time": 2.3083314374962356,
+            "avg_time": 2.306937637476949,
             "counter": 388
         },
         "with_print_no_cache": {
-            "avg_time": 3.451982950005913,
+            "avg_time": 3.4038116500305478,
             "counter": 388
         },
         "without_print_cache": {
             "avg_time": 0.856108075066004,
             "counter": 388
         },
         "without_print_no_cache": {
-            "avg_time": 1.9954930499952752,
+            "avg_time": 1.946089800039772,
             "counter": 388
         }
     },