troessner/reek

Features

• Code Smell Detectors - Automatically scans Ruby source files to identify design flaws and maintainability issues known as code smells.
• Ruby Linting Tools - Scans Ruby source code to identify design flaws and maintainability issues using static analysis.
• Architectural Debt Detectors - Acts as a software analysis engine for automating the detection of architectural debt in Ruby codebases.
• Data Clump Detectors - Identifies groups of parameters that frequently appear together, signaling missing abstractions and duplicate code.
• Quality Governance Systems - Enforces architectural standards by defining project-specific thresholds and exclusion rules for code quality.
• Static Analysis Rule Configurations - Offers adjustable detector sensitivity for configuring thresholds on method length, constant counts, and other metrics.
• Long Parameter List Detectors - Identifies methods or blocks that exceed a specified number of parameters to highlight potential smells.
• Control Coupling Detectors - Detects methods that use parameters to decide execution paths, signaling potential duplication or fragmented responsibilities.
• Code Smell Scanners - Scans source files in directories or via standard input to identify design flaws and maintainability issues.
• Feature Envy Detectors - Identifies methods that reference other objects more than their own class to signal misplaced logic.
• Large Class Detectors - Identifies classes that exceed thresholds for constants, instance variables, or method counts.
• Long Method Detectors - Identifies methods with too many statements by counting operations and logic within control structures.
• Metric-Based Heuristics - Evaluates code metrics against configurable numeric limits to determine if a specific code smell is present.
• Simulated Polymorphism Detectors - Identifies case statements and repetitive conditionals where polymorphism should replace manual dispatch.
• Detector Toggles - Provides control over detector toggles and thresholds via configuration files, command-line switches, and inline comments.
• Static Analysis AST Parsing - Utilizes abstract syntax tree parsing to detect structural design flaws and code smells in Ruby source code.
• Static Code Analyzers - Inspects Ruby source code without execution to find structural weaknesses and potential bugs.
• Static Analysis Reports - Generates analysis results in text, JSON, YAML, HTML, and XML formats for flexible consumption.
• Analysis File Filters - Allows the inclusion or exclusion of specific files and directories from analysis using external configuration and regular expressions.
• Automated Code Analysis Tools - Provides capabilities to automate quality checks across the development lifecycle by linking analysis to build tasks and APIs.
• Code Refactoring Tools - Facilitates the gradual cleanup of legacy Ruby codebases through the use of issue baselining to manage technical debt.
• External Configuration Loading - Supports loading custom configuration files from the filesystem to override default analysis settings.
• Directory-Specific Policies - Allows customization of detector settings for specific project subdirectories to accommodate different architectural patterns.
• Pluggable Formatters - Implements a pluggable architecture for report formatters, supporting various outputs like JSON, YAML, XML, and HTML.
• Build and Task Automation - Integrates source file analysis as a build task via tools like Rake for automated quality gating.
• Continuous Integration Checks - Supports integration into continuous integration pipelines, including containerized analysis for tools like CodeClimate.
• Unused Parameter Detection - Identifies method parameters that are declared but never referenced within the function body.
• Lint Report Exports - Exports detected code smells in JSON, XML, and YAML formats for integration with external quality tools.
• Analysis Rule Filters - Allows restricting analysis to a specific set of smells to focus on particular architectural quality issues.
• Dead Method Detectors - Detects private instance methods that are never called within a class to reduce maintenance overhead.
• Issue Baselining - Provides mechanisms to snapshot existing issues as a baseline to ignore legacy warnings and focus on new regressions.
• Naming Convention Analyzers - Identifies poorly named methods, modules, parameters, and variables that fail to clearly communicate intent.
• State Dependency Analyzers - Identifies instance methods that do not depend on object state, signaling a need for relocation to utility modules.
• Warning Suppressions - Provides mechanisms to disable specific linting rules and warnings using configuration files or inline comments.
• Analysis Scope Filters - Includes configuration mechanisms to target or exclude specific files and directories during the analysis process.
• Static Code Analysis - Integrates automated scanning for maintainability issues into continuous integration pipelines to detect regressions.
• Code Analysis and Metrics - Detector for common code smells in source files.
• Static Analysis Tools - Code smell detector for Ruby.

Star history