thailint 0.9.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

src/linters/nesting/linter.py

@@ -24,7 +24,7 @@ from typing import Any
 from src.core.base import BaseLintContext, MultiLanguageLintRule
 from src.core.linter_utils import load_linter_config
 from src.core.types import Violation
-from src.linter_config.ignore import IgnoreDirectiveParser
+from src.linter_config.ignore import get_ignore_parser
 
 from .config import NestingConfig
 from .python_analyzer import PythonNestingAnalyzer
@@ -37,8 +37,11 @@ class NestingDepthRule(MultiLanguageLintRule):
 
     def __init__(self) -> None:
         """Initialize the nesting depth rule."""
-        self._ignore_parser = IgnoreDirectiveParser()
+        self._ignore_parser = get_ignore_parser()
         self._violation_builder = NestingViolationBuilder(self.rule_id)
+        # Singleton analyzers for performance (avoid recreating per-file)
+        self._python_analyzer = PythonNestingAnalyzer()
+        self._typescript_analyzer = TypeScriptNestingAnalyzer()
 
     @property
     def rule_id(self) -> str:
@@ -108,9 +111,8 @@ class NestingDepthRule(MultiLanguageLintRule):
         except SyntaxError as e:
             return [self._violation_builder.create_syntax_error_violation(e, context)]
 
-        analyzer = PythonNestingAnalyzer()
-        functions = analyzer.find_all_functions(tree)
-        return self._process_python_functions(functions, analyzer, config, context)
+        functions = self._python_analyzer.find_all_functions(tree)
+        return self._process_python_functions(functions, self._python_analyzer, config, context)
 
     def _process_typescript_functions(
         self, functions: list, analyzer: Any, config: NestingConfig, context: BaseLintContext
@@ -149,13 +151,14 @@ class NestingDepthRule(MultiLanguageLintRule):
         Returns:
             List of violations found in TypeScript code
         """
-        analyzer = TypeScriptNestingAnalyzer()
-        root_node = analyzer.parse_typescript(context.file_content or "")
+        root_node = self._typescript_analyzer.parse_typescript(context.file_content or "")
         if root_node is None:
             return []
 
-        functions = analyzer.find_all_functions(root_node)
-        return self._process_typescript_functions(functions, analyzer, config, context)
+        functions = self._typescript_analyzer.find_all_functions(root_node)
+        return self._process_typescript_functions(
+            functions, self._typescript_analyzer, config, context
+        )
 
     def _should_ignore(self, violation: Violation, context: BaseLintContext) -> bool:
         """Check if violation should be ignored based on inline directives.

src/linters/print_statements/linter.py

@@ -29,7 +29,8 @@ from pathlib import Path
 from src.core.base import BaseLintContext, MultiLanguageLintRule
 from src.core.linter_utils import load_linter_config
 from src.core.types import Violation
-from src.linter_config.ignore import IgnoreDirectiveParser
+from src.core.violation_utils import get_violation_line, has_python_noqa, has_typescript_noqa
+from src.linter_config.ignore import get_ignore_parser
 
 from .config import PrintStatementConfig
 from .python_analyzer import PythonPrintStatementAnalyzer
@@ -42,7 +43,7 @@ class PrintStatementRule(MultiLanguageLintRule):  # thailint: ignore[srp]
 
     def __init__(self) -> None:
         """Initialize the print statements rule."""
-        self._ignore_parser = IgnoreDirectiveParser()
+        self._ignore_parser = get_ignore_parser()
         self._violation_builder = ViolationBuilder(self.rule_id)
 
     @property
@@ -255,27 +256,16 @@ class PrintStatementRule(MultiLanguageLintRule):  # thailint: ignore[srp]
         Returns:
             True if line has generic ignore directive
         """
-        line_text = self._get_violation_line(violation, context)
+        line_text = get_violation_line(violation, context)
         if line_text is None:
             return False
         return self._has_generic_ignore_directive(line_text)
 
-    def _get_violation_line(self, violation: Violation, context: BaseLintContext) -> str | None:
-        """Get the line text for a violation."""
-        if not context.file_content:
-            return None
-
-        lines = context.file_content.splitlines()
-        if violation.line <= 0 or violation.line > len(lines):
-            return None
-
-        return lines[violation.line - 1].lower()
-
     def _has_generic_ignore_directive(self, line_text: str) -> bool:
         """Check if line has generic ignore directive."""
         if self._has_generic_thailint_ignore(line_text):
             return True
-        return self._has_noqa_directive(line_text)
+        return has_python_noqa(line_text)
 
     def _has_generic_thailint_ignore(self, line_text: str) -> bool:
         """Check for generic thailint: ignore (no brackets)."""
@@ -284,10 +274,6 @@ class PrintStatementRule(MultiLanguageLintRule):  # thailint: ignore[srp]
         after_ignore = line_text.split("# thailint: ignore")[1].split("#")[0]
         return "[" not in after_ignore
 
-    def _has_noqa_directive(self, line_text: str) -> bool:
-        """Check for noqa-style comments."""
-        return "# noqa" in line_text
-
     def _check_typescript(
         self, context: BaseLintContext, config: PrintStatementConfig
     ) -> list[Violation]:
@@ -400,7 +386,7 @@ class PrintStatementRule(MultiLanguageLintRule):  # thailint: ignore[srp]
         Returns:
             True if line has ignore directive
         """
-        line_text = self._get_violation_line(violation, context)
+        line_text = get_violation_line(violation, context)
         if line_text is None:
             return False
         return self._has_typescript_ignore_directive(line_text)
@@ -422,7 +408,4 @@ class PrintStatementRule(MultiLanguageLintRule):  # thailint: ignore[srp]
             if "[" not in after_ignore:
                 return True
 
-        if "// noqa" in line_text:
-            return True
-
-        return False
+        return has_typescript_noqa(line_text)

src/linters/srp/class_analyzer.py

@@ -32,8 +32,10 @@ class ClassAnalyzer:
     """Coordinates class analysis for Python and TypeScript."""
 
     def __init__(self) -> None:
-        """Initialize the class analyzer."""
-        pass  # Coordinates analysis between language-specific analyzers
+        """Initialize the class analyzer with singleton analyzers."""
+        # Singleton analyzers for performance (avoid recreating per-file)
+        self._python_analyzer = PythonSRPAnalyzer()
+        self._typescript_analyzer = TypeScriptSRPAnalyzer()
 
     def analyze_python(
         self, context: BaseLintContext, config: SRPConfig
@@ -51,10 +53,9 @@ class ClassAnalyzer:
         if isinstance(tree, list):  # Syntax error violations
             return tree
 
-        analyzer = PythonSRPAnalyzer()
-        classes = analyzer.find_all_classes(tree)
+        classes = self._python_analyzer.find_all_classes(tree)
         return [
-            analyzer.analyze_class(class_node, context.file_content or "", config)
+            self._python_analyzer.analyze_class(class_node, context.file_content or "", config)
             for class_node in classes
         ]
 
@@ -70,14 +71,13 @@ class ClassAnalyzer:
         Returns:
             List of class metrics dicts
         """
-        analyzer = TypeScriptSRPAnalyzer()
-        root_node = analyzer.parse_typescript(context.file_content or "")
+        root_node = self._typescript_analyzer.parse_typescript(context.file_content or "")
         if not root_node:
             return []
 
-        classes = analyzer.find_all_classes(root_node)
+        classes = self._typescript_analyzer.find_all_classes(root_node)
         return [
-            analyzer.analyze_class(class_node, context.file_content or "", config)
+            self._typescript_analyzer.analyze_class(class_node, context.file_content or "", config)
             for class_node in classes
         ]
 

src/linters/srp/heuristics.py

@@ -33,9 +33,10 @@ def count_methods(class_node: ast.ClassDef) -> int:
         Number of methods in the class
     """
     methods = 0
-    for node in class_node.body:
-        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            continue
+    func_nodes = (
+        n for n in class_node.body if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))
+    )
+    for node in func_nodes:
         # Don't count @property decorators as methods
         if not has_property_decorator(node):
             methods += 1
@@ -56,8 +57,8 @@ def count_loc(class_node: ast.ClassDef, source: str) -> int:
     end_line = class_node.end_lineno or start_line
     lines = source.split("\n")[start_line - 1 : end_line]
 
-    # Filter out blank lines and comments
-    code_lines = [line for line in lines if line.strip() and not line.strip().startswith("#")]
+    # Filter out blank lines and comments (using walrus operator to avoid double strip)
+    code_lines = [s for line in lines if (s := line.strip()) and not s.startswith("#")]
     return len(code_lines)
 
 

src/linters/srp/linter.py

@@ -21,7 +21,7 @@ Implementation: Composition pattern with helper classes, heuristic-based SRP ana
 from src.core.base import BaseLintContext, MultiLanguageLintRule
 from src.core.linter_utils import load_linter_config
 from src.core.types import Violation
-from src.linter_config.ignore import IgnoreDirectiveParser
+from src.linter_config.ignore import get_ignore_parser
 
 from .class_analyzer import ClassAnalyzer
 from .config import SRPConfig
@@ -34,7 +34,7 @@ class SRPRule(MultiLanguageLintRule):
 
     def __init__(self) -> None:
         """Initialize the SRP rule."""
-        self._ignore_parser = IgnoreDirectiveParser()
+        self._ignore_parser = get_ignore_parser()
         self._class_analyzer = ClassAnalyzer()
         self._violation_builder = ViolationBuilder()
 
@@ -171,9 +171,8 @@ class SRPRule(MultiLanguageLintRule):
             List of violations
         """
         violations = []
-        for metrics in metrics_list:
-            if not isinstance(metrics, dict):
-                continue
+        valid_metrics = (m for m in metrics_list if isinstance(m, dict))
+        for metrics in valid_metrics:
             violation = self._create_violation_if_needed(metrics, config, context)
             if violation:
                 violations.append(violation)

src/linters/stateless_class/linter.py

@@ -26,7 +26,7 @@ from pathlib import Path
 
 from src.core.base import BaseLintContext, BaseLintRule
 from src.core.types import Severity, Violation
-from src.linter_config.ignore import IgnoreDirectiveParser
+from src.linter_config.ignore import get_ignore_parser
 
 from .config import StatelessClassConfig
 from .python_analyzer import ClassInfo, StatelessClassAnalyzer
@@ -37,7 +37,7 @@ class StatelessClassRule(BaseLintRule):  # thailint: ignore[srp,dry]
 
     def __init__(self) -> None:
         """Initialize the rule with analyzer and ignore parser."""
-        self._ignore_parser = IgnoreDirectiveParser()
+        self._ignore_parser = get_ignore_parser()
 
     @property
     def rule_id(self) -> str:

src/linters/stringly_typed/__init__.py

@@ -0,0 +1,23 @@
+"""
+Purpose: Stringly-typed linter package exports
+
+Scope: Public API for stringly-typed linter module
+
+Overview: Provides the public interface for the stringly-typed linter package. Exports
+    StringlyTypedConfig for configuration of the linter. The stringly-typed linter detects
+    code patterns where plain strings are used instead of proper enums or typed alternatives,
+    helping identify potential type safety improvements. This module serves as the entry
+    point for users of the stringly-typed linter.
+
+Dependencies: .config for StringlyTypedConfig
+
+Exports: StringlyTypedConfig dataclass
+
+Interfaces: Configuration loading via StringlyTypedConfig.from_dict()
+
+Implementation: Module-level exports with __all__ definition
+"""
+
+from src.linters.stringly_typed.config import StringlyTypedConfig
+
+__all__ = ["StringlyTypedConfig"]

src/linters/stringly_typed/config.py

@@ -0,0 +1,165 @@
+"""
+Purpose: Configuration dataclass for stringly-typed linter
+
+Scope: Define configurable options for stringly-typed pattern detection
+
+Overview: Provides StringlyTypedConfig for customizing linter behavior including minimum
+    occurrences required to flag patterns, enum value thresholds, cross-file detection
+    settings, and ignore patterns. The stringly-typed linter detects code patterns where
+    plain strings are used instead of proper enums or typed alternatives. Integrates with
+    the orchestrator's configuration system to allow users to customize detection via
+    .thailint.yaml configuration files. Follows the same configuration pattern as other
+    thai-lint linters.
+
+Dependencies: dataclasses, typing
+
+Exports: StringlyTypedConfig dataclass, default constants
+
+Interfaces: StringlyTypedConfig.from_dict() class method for configuration loading
+
+Implementation: Dataclass with sensible defaults, validation in __post_init__, and config
+    loading from dictionary with language-specific override support. Pylint
+    too-many-instance-attributes suppressed because configuration dataclasses inherently
+    require multiple cohesive fields (8 attributes for detection thresholds, filtering,
+    cross-file settings). Splitting would reduce cohesion without benefit. This follows
+    the established pattern in DRYConfig which has the same suppression.
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+# Default thresholds
+DEFAULT_MIN_OCCURRENCES = 2
+DEFAULT_MIN_VALUES_FOR_ENUM = 2
+DEFAULT_MAX_VALUES_FOR_ENUM = 6
+
+
+@dataclass
+class StringlyTypedConfig:  # pylint: disable=too-many-instance-attributes
+    """Configuration for stringly-typed linter.
+
+    Note: Pylint too-many-instance-attributes disabled. This is a configuration
+    dataclass serving as a data container for related stringly-typed linter settings.
+    All 8 attributes are cohesively related (detection thresholds, filtering options,
+    cross-file settings, exclusion patterns). Splitting would reduce cohesion and make
+    configuration loading more complex without meaningful benefit. This follows the
+    established pattern in DRYConfig.
+    """
+
+    enabled: bool = True
+    """Whether the linter is enabled."""
+
+    min_occurrences: int = DEFAULT_MIN_OCCURRENCES
+    """Minimum number of cross-file occurrences required to flag a violation."""
+
+    min_values_for_enum: int = DEFAULT_MIN_VALUES_FOR_ENUM
+    """Minimum number of unique string values to suggest an enum."""
+
+    max_values_for_enum: int = DEFAULT_MAX_VALUES_FOR_ENUM
+    """Maximum number of unique string values to suggest an enum (above this, not enum-worthy)."""
+
+    require_cross_file: bool = True
+    """Whether to require cross-file occurrences to flag violations."""
+
+    ignore: list[str] = field(default_factory=list)
+    """File patterns to ignore."""
+
+    allowed_string_sets: list[list[str]] = field(default_factory=list)
+    """String sets that are allowed and should not be flagged."""
+
+    exclude_variables: list[str] = field(default_factory=list)
+    """Variable names to exclude from detection."""
+
+    def __post_init__(self) -> None:
+        """Validate configuration values."""
+        if self.min_occurrences < 1:
+            raise ValueError(f"min_occurrences must be at least 1, got {self.min_occurrences}")
+        if self.min_values_for_enum < 2:
+            raise ValueError(
+                f"min_values_for_enum must be at least 2, got {self.min_values_for_enum}"
+            )
+        if self.max_values_for_enum < self.min_values_for_enum:
+            raise ValueError(
+                f"max_values_for_enum ({self.max_values_for_enum}) must be >= "
+                f"min_values_for_enum ({self.min_values_for_enum})"
+            )
+
+    @classmethod
+    def from_dict(
+        cls, config: dict[str, Any], language: str | None = None
+    ) -> "StringlyTypedConfig":
+        """Load configuration from dictionary.
+
+        Args:
+            config: Dictionary containing configuration values
+            language: Programming language for language-specific overrides
+
+        Returns:
+            StringlyTypedConfig instance with values from dictionary
+        """
+        # Check for language-specific overrides first
+        if language and language in config:
+            lang_config = config[language]
+            return cls._from_merged_config(config, lang_config)
+
+        return cls._from_base_config(config)
+
+    @classmethod
+    def _from_base_config(cls, config: dict[str, Any]) -> "StringlyTypedConfig":
+        """Create config from base configuration dictionary.
+
+        Args:
+            config: Base configuration dictionary
+
+        Returns:
+            StringlyTypedConfig instance
+        """
+        return cls(
+            enabled=config.get("enabled", True),
+            min_occurrences=config.get("min_occurrences", DEFAULT_MIN_OCCURRENCES),
+            min_values_for_enum=config.get("min_values_for_enum", DEFAULT_MIN_VALUES_FOR_ENUM),
+            max_values_for_enum=config.get("max_values_for_enum", DEFAULT_MAX_VALUES_FOR_ENUM),
+            require_cross_file=config.get("require_cross_file", True),
+            ignore=config.get("ignore", []),
+            allowed_string_sets=config.get("allowed_string_sets", []),
+            exclude_variables=config.get("exclude_variables", []),
+        )
+
+    @classmethod
+    def _from_merged_config(
+        cls, base_config: dict[str, Any], lang_config: dict[str, Any]
+    ) -> "StringlyTypedConfig":
+        """Create config with language-specific overrides merged.
+
+        Args:
+            base_config: Base configuration dictionary
+            lang_config: Language-specific configuration overrides
+
+        Returns:
+            StringlyTypedConfig instance with merged values
+        """
+        return cls(
+            enabled=lang_config.get("enabled", base_config.get("enabled", True)),
+            min_occurrences=lang_config.get(
+                "min_occurrences",
+                base_config.get("min_occurrences", DEFAULT_MIN_OCCURRENCES),
+            ),
+            min_values_for_enum=lang_config.get(
+                "min_values_for_enum",
+                base_config.get("min_values_for_enum", DEFAULT_MIN_VALUES_FOR_ENUM),
+            ),
+            max_values_for_enum=lang_config.get(
+                "max_values_for_enum",
+                base_config.get("max_values_for_enum", DEFAULT_MAX_VALUES_FOR_ENUM),
+            ),
+            require_cross_file=lang_config.get(
+                "require_cross_file", base_config.get("require_cross_file", True)
+            ),
+            ignore=lang_config.get("ignore", base_config.get("ignore", [])),
+            allowed_string_sets=lang_config.get(
+                "allowed_string_sets", base_config.get("allowed_string_sets", [])
+            ),
+            exclude_variables=lang_config.get(
+                "exclude_variables", base_config.get("exclude_variables", [])
+            ),
+        )

src/linters/stringly_typed/python/__init__.py

@@ -0,0 +1,29 @@
+"""
+Purpose: Python-specific detection for stringly-typed patterns
+
+Scope: Python AST analysis for membership validation and equality chain detection
+
+Overview: Exposes Python analysis components for detecting stringly-typed patterns in Python
+    source code. Includes validation_detector for finding 'x in ("a", "b")' patterns,
+    conditional_detector for finding if/elif chains and match statements, and analyzer
+    for coordinating detection across Python files. Uses AST traversal to identify where
+    plain strings are used instead of proper enums or typed alternatives.
+
+Dependencies: ast module for Python AST parsing
+
+Exports: MembershipValidationDetector, ConditionalPatternDetector, PythonStringlyTypedAnalyzer
+
+Interfaces: Detector and analyzer classes for Python stringly-typed pattern detection
+
+Implementation: AST NodeVisitor pattern for traversing Python syntax trees
+"""
+
+from .analyzer import PythonStringlyTypedAnalyzer
+from .conditional_detector import ConditionalPatternDetector
+from .validation_detector import MembershipValidationDetector
+
+__all__ = [
+    "ConditionalPatternDetector",
+    "MembershipValidationDetector",
+    "PythonStringlyTypedAnalyzer",
+]

src/linters/stringly_typed/python/analyzer.py

@@ -0,0 +1,198 @@
+"""
+Purpose: Coordinate Python stringly-typed pattern detection
+
+Scope: Orchestrate detection of all stringly-typed patterns in Python files
+
+Overview: Provides PythonStringlyTypedAnalyzer class that coordinates detection of
+    stringly-typed patterns across Python source files. Uses MembershipValidationDetector
+    to find 'x in ("a", "b")' patterns and ConditionalPatternDetector to find if/elif
+    chains and match statements. Returns unified AnalysisResult objects. Handles AST
+    parsing errors gracefully and provides a single entry point for Python analysis.
+    Supports configuration options for filtering and thresholds.
+
+Dependencies: ast module, MembershipValidationDetector, ConditionalPatternDetector,
+    StringlyTypedConfig
+
+Exports: PythonStringlyTypedAnalyzer class, AnalysisResult dataclass
+
+Interfaces: PythonStringlyTypedAnalyzer.analyze(code, file_path) -> list[AnalysisResult]
+
+Implementation: Facade pattern coordinating multiple detectors with unified result format
+"""
+
+import ast
+from dataclasses import dataclass
+from pathlib import Path
+
+from ..config import StringlyTypedConfig
+from .conditional_detector import ConditionalPatternDetector, EqualityChainPattern
+from .validation_detector import MembershipPattern, MembershipValidationDetector
+
+
+@dataclass
+class AnalysisResult:
+    """Represents a stringly-typed pattern detected in Python code.
+
+    Provides a unified representation of detected patterns from all detectors,
+    including pattern type, string values, location, and contextual information.
+    """
+
+    pattern_type: str
+    """Type of pattern detected: 'membership_validation', 'equality_chain', etc."""
+
+    string_values: set[str]
+    """Set of string values used in the pattern."""
+
+    file_path: Path
+    """Path to the file containing the pattern."""
+
+    line_number: int
+    """Line number where the pattern occurs (1-indexed)."""
+
+    column: int
+    """Column number where the pattern starts (0-indexed)."""
+
+    variable_name: str | None
+    """Variable name involved in the pattern, if identifiable."""
+
+    details: str
+    """Human-readable description of the detected pattern."""
+
+
+class PythonStringlyTypedAnalyzer:
+    """Analyzes Python code for stringly-typed patterns.
+
+    Coordinates detection of various stringly-typed patterns including membership
+    validation ('x in ("a", "b")') and equality chains ('if x == "a" elif x == "b"').
+    Provides configuration-aware analysis with filtering support.
+    """
+
+    def __init__(self, config: StringlyTypedConfig | None = None) -> None:
+        """Initialize the analyzer with optional configuration.
+
+        Args:
+            config: Configuration for stringly-typed detection. Uses defaults if None.
+        """
+        self.config = config or StringlyTypedConfig()
+        self._membership_detector = MembershipValidationDetector()
+        self._conditional_detector = ConditionalPatternDetector()
+
+    def analyze(self, code: str, file_path: Path) -> list[AnalysisResult]:
+        """Analyze Python code for stringly-typed patterns.
+
+        Args:
+            code: Python source code to analyze
+            file_path: Path to the file being analyzed
+
+        Returns:
+            List of AnalysisResult instances for each detected pattern
+        """
+        tree = self._parse_code(code)
+        if tree is None:
+            return []
+
+        results: list[AnalysisResult] = []
+
+        # Detect membership validation patterns
+        membership_patterns = self._membership_detector.find_patterns(tree)
+        results.extend(
+            self._convert_membership_pattern(pattern, file_path) for pattern in membership_patterns
+        )
+
+        # Detect equality chain patterns
+        conditional_patterns = self._conditional_detector.find_patterns(tree)
+        results.extend(
+            self._convert_conditional_pattern(pattern, file_path)
+            for pattern in conditional_patterns
+        )
+
+        return results
+
+    def _parse_code(self, code: str) -> ast.AST | None:
+        """Parse Python source code into an AST.
+
+        Args:
+            code: Python source code to parse
+
+        Returns:
+            AST if parsing succeeds, None if parsing fails
+        """
+        try:
+            return ast.parse(code)
+        except SyntaxError:
+            return None
+
+    def _convert_membership_pattern(
+        self, pattern: MembershipPattern, file_path: Path
+    ) -> AnalysisResult:
+        """Convert a MembershipPattern to unified AnalysisResult.
+
+        Args:
+            pattern: Detected membership pattern
+            file_path: Path to the file containing the pattern
+
+        Returns:
+            AnalysisResult representing the pattern
+        """
+        values_str = ", ".join(sorted(pattern.string_values))
+        var_info = f" on '{pattern.variable_name}'" if pattern.variable_name else ""
+        details = (
+            f"Membership validation{var_info} with {len(pattern.string_values)} "
+            f"string values ({pattern.operator}): {values_str}"
+        )
+
+        return AnalysisResult(
+            pattern_type="membership_validation",
+            string_values=pattern.string_values,
+            file_path=file_path,
+            line_number=pattern.line_number,
+            column=pattern.column,
+            variable_name=pattern.variable_name,
+            details=details,
+        )
+
+    def _convert_conditional_pattern(
+        self, pattern: EqualityChainPattern, file_path: Path
+    ) -> AnalysisResult:
+        """Convert an EqualityChainPattern to unified AnalysisResult.
+
+        Args:
+            pattern: Detected equality chain pattern
+            file_path: Path to the file containing the pattern
+
+        Returns:
+            AnalysisResult representing the pattern
+        """
+        values_str = ", ".join(sorted(pattern.string_values))
+        var_info = f" on '{pattern.variable_name}'" if pattern.variable_name else ""
+        pattern_label = self._get_pattern_label(pattern.pattern_type)
+        details = (
+            f"{pattern_label}{var_info} with {len(pattern.string_values)} "
+            f"string values: {values_str}"
+        )
+
+        return AnalysisResult(
+            pattern_type=pattern.pattern_type,
+            string_values=pattern.string_values,
+            file_path=file_path,
+            line_number=pattern.line_number,
+            column=pattern.column,
+            variable_name=pattern.variable_name,
+            details=details,
+        )
+
+    def _get_pattern_label(self, pattern_type: str) -> str:
+        """Get human-readable label for a pattern type.
+
+        Args:
+            pattern_type: The pattern type string
+
+        Returns:
+            Human-readable label for the pattern
+        """
+        labels = {
+            "equality_chain": "Equality chain",
+            "or_combined": "Or-combined comparison",
+            "match_statement": "Match statement",
+        }
+        return labels.get(pattern_type, "Conditional pattern")