# ๐๏ธ Garbage Code Hunter
[](https://www.rust-lang.org)
[](LICENSE)
[](https://crates.io/crates/garbage-code-hunter)
[]()
A humorous Rust code quality detector that roasts your garbage code with style! ๐ฅ
*The most sarcastic Rust static analysis assistant you'll ever meet* ๐ญ Make coding more interesting, and have fun ๐.
```
Inspiration from https://github.com/Done-0/fuck-u-code.git
```
Unlike traditional linters that give you dry, boring warnings, Garbage Code Hunter delivers **sarcastic, witty, and brutally honest** feedback about your code quality. It's like having a sassy code reviewer who isn't afraid to hurt your feelings (in a good way).
## โจ Features
- ๐ญ **Humorous Code Analysis**: Get roasted with style while learning better coding practices
- ๐ฃ๏ธ **Sarcastic Commentary**: Witty and educational feedback that makes code review fun
- ๐ **Multi-language Support**: Available in English and Chinese (more languages coming soon!)
- ๐ฏ **Smart Detection**: Identifies common code smells and anti-patterns
- ๐ฒ **Randomized Roasts**: Different witty comments every time you run it
- ๐ **Professional Reports**: Generate detailed analysis reports in multiple formats
- ๐ง **Highly Configurable**: Customize output, filtering, and analysis depth
- ๐ **Markdown Export**: Perfect for documentation and CI/CD integration
- ๐ **Fast & Lightweight**: Built with Rust for maximum performance
### ๐ **Enhanced Features**
- ๐ **Educational Mode**: Detailed explanations with code examples and best practices
- ๐ **Hall of Shame**: Project statistics and worst files ranking
- ๐ก **Smart Suggestions**: Targeted improvement recommendations based on detected issues
- ๐ **Advanced Scoring**: Comprehensive quality metrics with category breakdown
- ๐จ **Beautiful UI**: Card-style layouts with progress bars and visual indicators
- ๐ **File Structure Analysis**: Detects overly long files, import chaos, and deep module nesting
## ๐ฏ Detection Features
### ๐ **Naming Convention Checks**
- **Terrible Naming**: Detects meaningless variable names
- **Single Letter Variables**: Finds overused single-letter variables
- **Meaningless Naming**: Identifies placeholder names like `foo`, `bar`, `data`, `temp`
- **Hungarian Notation**: Detects outdated naming like `strName`, `intCount`
- **Abbreviation Abuse**: Finds confusing abbreviations like `mgr`, `ctrl`, `usr`, `pwd`
### ๐ง **Code Complexity Analysis**
- **Deep Nesting**: Detects nesting deeper than 3 levels
- **Long Functions**: Finds functions with too many lines
- **God Functions**: Identifies overly complex functions doing too much
### ๐ฆ **Rust-Specific Issues**
- **Unwrap Abuse**: Detects unsafe unwrap() usage
- **Unnecessary Clone**: Finds avoidable clone() calls
- **String Abuse**: Identifies places where `&str` should be used instead of `String`
- **Vec Abuse**: Detects unnecessary Vec allocations
- **Iterator Abuse**: Finds traditional loops that could use iterator chains
- **Match Abuse**: Identifies complex matches that could be simplified with `if let`
### ๐ฉ **Code Smell Detection**
- **Magic Numbers**: Detects hardcoded numeric constants
- **Commented Code**: Finds large blocks of commented-out code
- **Dead Code**: Identifies unreachable code
### ๐ **Student Code Patterns**
- **Printf Debugging**: Detects leftover debugging print statements
- **Panic Abuse**: Finds casual panic! usage
- **TODO Comments**: Counts excessive TODO/FIXME comments
### ๐ **Other Detections**
- **Code Duplication**: Finds repeated code blocks
- **Macro Abuse**: Detects excessive macro usage
- **Advanced Rust Patterns**: Complex closures, lifetime abuse, etc.
### ๐๏ธ **File Structure Analysis**
- **File Length**: Detects overly long files (>1000 lines)
- **Import Chaos**: Identifies unordered and duplicate imports
- **Module Nesting**: Detects overly deep module hierarchies
- **Project Organization**: Analyzes overall code structure quality
## ๐ Detection Rules Statistics
Our tool currently includes **20+ detection rules** covering the following categories:
| **Naming Conventions** | 5 | Various naming issues detection |
| **Code Complexity** | 3 | Code structure complexity analysis |
| **Rust-Specific** | 6 | Rust language-specific issue patterns |
| **Code Smells** | 4 | General code quality problems |
| **Student Code** | 3 | Common beginner code patterns |
| **File Structure** | 3 | File organization and import analysis |
| **Others** | 5+ | Code duplication, macro abuse, etc. |
**Total: 25+ rules** actively detecting garbage code patterns in your Rust projects! ๐๏ธ
## ๐ฏ Scoring System
Garbage Code Hunter includes a comprehensive **scientific scoring system** that evaluates your Rust code quality on a scale of **0-100**, where:
- **Lower scores = Better code quality** ๐
- **Higher scores = More problematic code** ๐
### ๐ Score Ranges & Quality Levels
| 0-20 | Excellent | ๐ | Outstanding code quality with minimal issues |
| 21-40 | Good | ๐ | Good code quality with minor improvements needed |
| 41-60 | Average | ๐ | Average code quality with room for improvement |
| 61-80 | Poor | ๐ | Poor code quality, refactoring recommended |
| 81-100 | Terrible | ๐ | Critical code quality issues, rewrite urgently needed |
### ๐งฎ Scoring Algorithm
The scoring system uses a **multi-factor algorithm** that considers:
#### 1. **Base Score Calculation**
Each detected issue contributes to the base score using:
```
Issue Score = Rule Weight ร Severity Weight
```
#### 2. **Rule Weights** (Impact Factor)
Different types of issues have different weights based on their impact:
| **Safety Critical** | `unsafe-abuse` | 5.0 | Memory safety violations |
| **FFI Critical** | `ffi-abuse` | 4.5 | Foreign function interface risks |
| **Runtime Critical** | `unwrap-abuse` | 4.0 | Potential panic sources |
| **Architecture** | `lifetime-abuse` | 3.5 | Complex lifetime management |
| **Async/Concurrency** | `async-abuse` | 3.5 | Async pattern misuse |
| **Complexity** | `deep-nesting` | 3.0 | Code maintainability |
| **Performance** | `unnecessary-clone` | 2.0 | Runtime efficiency |
| **Readability** | `terrible-naming` | 2.0 | Code comprehension |
#### 3. **Severity Weights**
Issues are classified by severity with corresponding multipliers:
- **Nuclear** (๐ฅ): 10.0ร - Critical issues that can cause crashes or security vulnerabilities
- **Spicy** (๐ถ๏ธ): 5.0ร - Serious issues affecting maintainability or performance
- **Mild** (๐): 2.0ร - Minor issues with style or best practices
#### 4. **Density Penalties**
Additional penalties based on issue concentration:
- **Issue Density**: Problems per 1000 lines of code
- \>50 issues/1000 lines: +25 penalty
- \>30 issues/1000 lines: +15 penalty
- \>20 issues/1000 lines: +10 penalty
- \>10 issues/1000 lines: +5 penalty
- **File Complexity**: Average issues per file
- \>20 issues/file: +15 penalty
- \>10 issues/file: +10 penalty
- \>5 issues/file: +5 penalty
#### 5. **Severity Distribution Penalties**
Extra penalties for problematic patterns:
- **Nuclear Issues**: First nuclear issue +20, each additional +5
- **Spicy Issues**: After 5 spicy issues, each additional +2
- **Mild Issues**: After 20 mild issues, each additional +0.5
### ๐ Metrics Included
The scoring system provides detailed metrics:
- **Total Score**: Overall code quality score (0-100)
- **Category Scores**: Breakdown by issue categories
- **Issue Density**: Problems per 1000 lines of code
- **Severity Distribution**: Count of nuclear/spicy/mild issues
- **File Count**: Number of analyzed Rust files
- **Total Lines**: Total lines of code analyzed
### ๐ฏ Interpretation Guide
**For Excellent Code (0-20):**
- Minimal issues detected
- Strong adherence to Rust best practices
- Good architecture and safety patterns
**For Good Code (21-40):**
- Few minor issues
- Generally well-structured
- Minor optimizations possible
**For Average Code (41-60):**
- Moderate number of issues
- Some refactoring beneficial
- Focus on complexity reduction
**For Poor Code (61-80):**
- Significant issues present
- Refactoring strongly recommended
- Address safety and complexity concerns
**For Terrible Code (81-100):**
- Critical issues requiring immediate attention
- Consider rewriting problematic sections
- Focus on safety, correctness, and maintainability
### ๐ฌ Scientific Approach
The scoring system is designed to be:
- **Objective**: Based on measurable code metrics
- **Weighted**: Critical issues have higher impact
- **Contextual**: Considers code size and complexity
- **Actionable**: Provides specific improvement areas
- **Consistent**: Reproducible results across runs
## ๐ช What It Detects
### Naming Disasters
- Terrible variable names (`data`, `temp`, `info`, `obj`)
- Single-letter variables (except common loop counters)
- Generic meaningless identifiers
### Code Structure Issues
- Deep nesting (Russian doll syndrome)
- Overly long functions
- Complex conditional logic
### Rust-Specific Anti-patterns
- `unwrap()` abuse (panic bombs ๐ฃ)
- Unnecessary `clone()` calls (memory waste)
- Poor error handling patterns
## ๐ Installation
### From Source
```bash
git clone https://github.com/yourusername/garbage-code-hunter.git
cd garbage-code-hunter
make install
```
### Using Cargo
```bash
cargo install garbage-code-hunter
```
## ๐ Usage
### Basic Usage
```bash
# Analyze current directory
cargo run
# Analyze specific file or directory
cargo run -- src/main.rs
cargo run -- src/
# Use make targets for convenience
make run ARGS="src/ --verbose"
make demo
```
### Language Options
```bash
# Chinese output (default)
garbage-code-hunter --lang zh-CN src/
# English output
garbage-code-hunter --lang en-US src/
```
### Advanced Options
```bash
# Verbose analysis with top 3 problematic files
garbage-code-hunter --verbose --top 3 --issues 5 src/
# Only show summary
garbage-code-hunter --summary src/
# Generate Markdown report
garbage-code-hunter --markdown src/ > code-quality-report.md
# Exclude files/directories
garbage-code-hunter --exclude "test_*" --exclude "target/*" src/
# Show only serious issues
garbage-code-hunter --harsh src/
```
### ๐ Enhanced Analysis Features
```bash
# Educational mode - provides detailed explanations and improvement suggestions for each issue type
cargo run -- src/ --educational
# Hall of Shame - shows statistics of worst files and most common issues
cargo run -- src/ --hall-of-shame
# Smart suggestions - generates targeted improvement recommendations based on actual issues
cargo run -- src/ --suggestions
# Combine features for comprehensive analysis report
cargo run -- src/ --hall-of-shame --suggestions --educational
# Example: Complete project analysis with all enhanced features
cargo run -- . --hall-of-shame --suggestions --lang en
# Quick analysis with suggestions only
cargo run -- src/ --suggestions --lang zh-CN
```
#### ๐ Educational Mode (`--educational`)
Provides detailed explanations for each detected issue:
- **Why it's problematic**: Clear explanation of the issue
- **How to fix**: Step-by-step improvement guide
- **Code examples**: Before/after code snippets
- **Best practices**: Links to Rust documentation and guidelines
#### ๐ Hall of Shame (`--hall-of-shame`)
Shows comprehensive project statistics:
- **Worst files ranking**: Files with most issues
- **Issue frequency analysis**: Most common problem patterns
- **Project metrics**: Garbage density, file count, total issues
- **Category breakdown**: Issues grouped by type
#### ๐ก Smart Suggestions (`--suggestions`)
Generates intelligent, data-driven recommendations:
- **Targeted advice**: Based on your actual code issues
- **Priority ranking**: Most critical improvements first
- **Actionable steps**: Specific, implementable suggestions
- **Progress tracking**: Measurable improvement goals
## ๐จ Sample Output
### English Mode
```
๐๏ธ Garbage Code Hunter ๐๏ธ
Preparing to roast your code...
๐ Code Quality Report
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
Found some areas for improvement:
๐ Issue Statistics:
8 ๐ฅ Nuclear Issues (fix immediately)
202 ๐ถ๏ธ Spicy Issues (should fix)
210 ๐ Mild Issues (can ignore)
420 ๐ Total
๐ Code Quality Score
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
๐ Score: 63.0/100 ๐
๐ฏ Level: Poor
๐ Lines of Code: 512
๐ Files: 2
๐ Issue Density: 82 issues/1k lines
๐ญ Issue Distribution:
๐ฅ Nuclear: 8
๐ถ๏ธ Spicy: 202
๐ Mild: 210
๐ Files with Most Issues
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
1. func.rs (231 issues)
2. ultimate_garbage_code_example.rs (189 issues)
๐ ultimate_garbage_code_example.rs
๐ฆ Nesting depth issues: 11 (depth 4-14)
โ ๏ธ panic abuse: 1
๐ Code duplication issues: 5 (multiple blocks)
โ ๏ธ god function: 1
โ ๏ธ magic number: 16
๐ func.rs
๐ฆ Nesting depth issues: 20 (depth 4-9)
๐ Code duplication issues: 9 (10 instances)
๐ท๏ธ Variable naming issues: 22 (temp, temp, data, data, data, ...)
โ ๏ธ println debugging: 1
๐ท๏ธ Variable naming issues: 128 (a, b, c, d, e, ...)
๐ Code Quality Report
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โญโ ๐ Overall Score โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโฎ
โ โ
โ Score: 63.0/100 โโโโโโโโโโโโโโโโโโโโ (๐ Poor)โ
โ โ
โ Files analyzed: 2 Total issues: 420 โ
โ โ
โฐโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโฏ
๐ Category Scores
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ ๐ท๏ธ Naming [ 90] โโโโโโโโโโโโโโโโโโโโ Terrible, urgent fixes needed
๐ฌ Variable names harder to decode than alien language ๐ฝ
โ ๐งฉ Complexity [ 90] โโโโโโโโโโโโโโโโโโโโ Terrible, urgent fixes needed
๐ฌ More nesting levels than Russian dolls ๐ช
โ ๐ Duplication [ 90] โโโโโโโโโโโโโโโโโโโโ Terrible, urgent fixes needed
๐ฌ This duplication level deserves a Guinness World Record ๐
โโ ๐ฆ Rust Basics [ 0] โโโโโโโโโโโโโโโโโโโโ Excellent, keep it up
โโ โก Advanced Rust [ 0] โโโโโโโโโโโโโโโโโโโโ Excellent, keep it up
โ ๐ Rust Features [ 90] โโโโโโโโโโโโโโโโโโโโ Terrible, urgent fixes needed
๐ฌ Rust community would shed tears seeing this code ๐ฆ
โโ ๐๏ธ Code Structure [ 0] โโโโโโโโโโโโโโโโโโโโ Excellent, keep it up
๐ Scoring Scale (higher score = worse code)
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
๐ 81-100: Terrible, rewrite needed ๐ฅ 61-80: Poor, refactoring recommended
โ ๏ธ 41-60: Average, needs improvement โ
21-40: Good, room for improvement
๐ 0-20: Excellent, keep it up
Keep working to make your code better! ๐
```
### Chinese Mode
```
๐๏ธ ๅๅพไปฃ็ ็ไบบ ๐๏ธ
ๆญฃๅจๅๅคๅๆงฝไฝ ็ไปฃ็ ...
๐ ๅๅพไปฃ็ ๆฃๆตๆฅๅ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
ๅ็ฐไบไธไบ้่ฆๆน่ฟ็ๅฐๆน๏ผ
๐ ้ฎ้ข็ป่ฎก:
8 ๐ฅ ๆ ธๅผน็บง้ฎ้ข (้่ฆ็ซๅณไฟฎๅค)
202 ๐ถ๏ธ ่พฃ็ผ็้ฎ้ข (ๅปบ่ฎฎไฟฎๅค)
210 ๐ ่ฝปๅพฎ้ฎ้ข (ๅฏไปฅๅฟฝ็ฅ)
420 ๐ ๆป่ฎก
๐ ไปฃ็ ่ดจ้่ฏๅ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
๐ ๆปๅ: 63.0/100 ๐
๐ฏ ็ญ็บง: ่พๅทฎ
๐ ไปฃ็ ่กๆฐ: 512
๐ ๆไปถๆฐ้: 2
๐ ้ฎ้ขๅฏๅบฆ: 82 ้ฎ้ข/ๅ่ก
๐ญ ้ฎ้ขๅๅธ:
๐ฅ ๆ ธๅผน็บง: 8
๐ถ๏ธ ไธฅ้: 202
๐ ่ฝปๅพฎ: 210
๐ ้ฎ้ขๆๅค็ๆไปถ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
1. func.rs (231 issues)
2. ultimate_garbage_code_example.rs (189 issues)
๐ func.rs
๐ฆ ๅตๅฅๆทฑๅบฆ้ฎ้ข: 20 (ๆทฑๅบฆๅตๅฅ)
๐ ไปฃ็ ้ๅค้ฎ้ข: 9 (6 instances)
๐ท๏ธ ๅ้ๅฝๅ้ฎ้ข: 22 (temp, temp, data, data, data, ...)
โ ๏ธ println ่ฐ่ฏ: 1
๐ท๏ธ ๅ้ๅฝๅ้ฎ้ข: 128 (a, b, c, d, e, ...)
๐ ultimate_garbage_code_example.rs
๐ฆ ๅตๅฅๆทฑๅบฆ้ฎ้ข: 11 (ๆทฑๅบฆๅตๅฅ)
โ ๏ธ panic ๆปฅ็จ: 1
๐ ไปฃ็ ้ๅค้ฎ้ข: 5 (ๅคไธชไปฃ็ ๅ)
โ ๏ธ ไธๅธๅฝๆฐ: 1
โ ๏ธ ้ญๆณๆฐๅญ: 16
๐ ไปฃ็ ่ดจ้ๆฅๅ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โญโ ๐ ๆปไฝ่ฏๅ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโฎ
โ โ
โ ๆปๅ: 63.0/100 โโโโโโโโโโโโโโโโโโโโ (๐ ่พๅทฎ)โ
โ โ
โ ๅๆๆไปถ: 2 ไธช ้ฎ้ขๆปๆฐ: 420 ไธช โ
โ โ
โฐโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโฏ
๐ ๅ็ฑป่ฏๅ่ฏฆๆ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ ๐ท๏ธ ๅฝๅ่ง่ [ 90ๅ] โโโโโโโโโโโโโโโโโโโโ ็ณ็ณ๏ผๆฅ้ไฟฎๅค
๐ฌ ๅ้ๅ็ๅๆ็จๅบฆ่ถ
่ถไบๆ็็่งฃ ๐
โ ๐งฉ ๅคๆๅบฆ [ 90ๅ] โโโโโโโโโโโโโโโโโโโโ ็ณ็ณ๏ผๆฅ้ไฟฎๅค
๐ฌ ๅฝๆฐ้ฟๅบฆๅทฒ็ป็ช็ ดๅคฉ้
๐
โ ๐ ไปฃ็ ้ๅค [ 90ๅ] โโโโโโโโโโโโโโโโโโโโ ็ณ็ณ๏ผๆฅ้ไฟฎๅค
๐ฌ ๅปบ่ฎฎๆนๅไธบcopy-paste.rs ๐
โโ ๐ฆ Rustๅบ็ก [ 0ๅ] โโโโโโโโโโโโโโโโโโโโ ไผ็ง๏ผ็ปง็ปญไฟๆ
โโ โก ้ซ็บง็นๆง [ 0ๅ] โโโโโโโโโโโโโโโโโโโโ ไผ็ง๏ผ็ปง็ปญไฟๆ
โ ๐ Rustๅ่ฝ [ 90ๅ] โโโโโโโโโโโโโโโโโโโโ ็ณ็ณ๏ผๆฅ้ไฟฎๅค
๐ฌ ๅปบ่ฎฎ้ๆฐๅญฆไน Rust ๆไฝณๅฎ่ทต ๐
โโ ๐๏ธ ไปฃ็ ็ปๆ [ 0ๅ] โโโโโโโโโโโโโโโโโโโโ ไผ็ง๏ผ็ปง็ปญไฟๆ
๐ ่ฏๅๆ ๅ (ๅๆฐ่ถ้ซไปฃ็ ่ถ็)
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
๐ 81-100ๅ: ็ณ็ณ๏ผๆฅ้้ๅ ๐ฅ 61-80ๅ: ่พๅทฎ๏ผๅปบ่ฎฎ้ๆ
โ ๏ธ 41-60ๅ: ไธ่ฌ๏ผ้่ฆๆน่ฟ โ
21-40ๅ: ่ฏๅฅฝ๏ผ่ฟๆๆๅ็ฉบ้ด
๐ 0-20ๅ: ไผ็ง๏ผ็ปง็ปญไฟๆ
็ปง็ปญๅชๅ๏ผ่ฎฉไปฃ็ ๅๅพๆดๅฅฝ๏ผ๐
```
## ๐ ๏ธ Command Line Options
| `--help` | `-h` | Show help message |
| `--verbose` | `-v` | Show detailed analysis report |
| `--top N` | `-t N` | Show top N files with most issues (default: 5) |
| `--issues N` | `-i N` | Show N issues per file (default: 5) |
| `--summary` | `-s` | Only show summary conclusion |
| `--markdown` | `-m` | Output Markdown format report |
| `--lang LANG` | `-l LANG` | Output language (zh-CN, en-US) |
| `--exclude PATTERN` | `-e PATTERN` | Exclude file/directory patterns |
| `--harsh` | | Show only the worst offenders |
| `--suggestions` | | Show suggestion for optimizing code |
| `--educational` | | Show educational advice for each issue type |
| `--hall-of-shame` | | Show hall of shame (worst files and patterns) |
## ๐ง Development
### Prerequisites
- Rust 1.70 or later
- Cargo
### Building
```bash
# Debug build
make build
# Release build
make release
# Run tests
make test
# Format code
make fmt
# Run linter
make clippy
```
### Running Demo
```bash
make demo
```
This creates a sample file with intentionally bad code and runs the analyzer on it.
## ๐ฏ Examples
### CI/CD Integration
```yaml
# GitHub Actions example
- name: Code Quality Check
run: |
cargo install garbage-code-hunter
garbage-code-hunter --markdown --lang en-US src/ > quality-report.md
# Upload report as artifact or comment on PR
```
### Pre-commit Hook
```bash
#!/bin/bash
# .git/hooks/pre-commit
garbage-code-hunter --harsh --summary src/
if [ $? -ne 0 ]; then
echo "Code quality issues detected. Please fix before committing."
exit 1
fi
```
## ๐ค Contributing
We welcome contributions! Here's how you can help:
1. **Add New Rules**: Implement additional code smell detection
2. **Language Support**: Add translations for more languages
3. **Improve Messages**: Make the roasts even funnier (but still helpful)
4. **Documentation**: Help improve docs and examples
5. **Bug Reports**: Found a bug? Let us know!
### Adding New Detection Rules
1. Create a new rule in `src/rules/`
2. Implement the `Rule` trait
3. Add humorous messages in `src/i18n.rs`
4. Add tests
5. Submit a PR!
## ๐ License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
## ๐ Acknowledgments
- Inspired by the need for more entertaining code reviews
- Built with โค๏ธ and a lot of โ
- Thanks to all the developers who write garbage code (we've all been there!)
## ๐ Links
- [Documentation](https://docs.rs/garbage-code-hunter)
- [Crates.io](https://crates.io/crates/garbage-code-hunter)
- [GitHub Repository](https://github.com/TimWood0x10/garbage-code-hunter)
- [Issue Tracker](https://github.com/TimWood0x10/garbage-code-hunter/issues)
---
**Remember**: The goal isn't to shame developers, but to make code quality improvement fun and memorable. Happy coding! ๐